# tools/core/strings/venue.strings.ts

> 334 lines of code and 79 definitions.

Tree: Coordination tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-tools-core-strings-venue-strings-ts
Source text: https://banes-lab.com/assets/sources/source.6367ca48a55ee89fe6d17736280e8c1366692e7986cc979d731b6e2af64ace53.generated.txt

## Definitions

- `markerContended` (lexical_declaration, line 105, exported)
- `deferredSectionMissing` (lexical_declaration, line 94, exported)
- `authorityHeld` (lexical_declaration, line 1, exported)
- `recordSurfaceMissing` (lexical_declaration, line 19, exported)
- `recordExists` (lexical_declaration, line 23, exported)
- `recordTemplateMissing` (lexical_declaration, line 27, exported)
- `recordTemplateEmpty` (lexical_declaration, line 31, exported)
- `recordAnchorMissing` (lexical_declaration, line 35, exported)
- `recordAdded` (lexical_declaration, line 46, exported)
- `successorVenueMissing` (lexical_declaration, line 56, exported)
- `successorNotPlanned` (lexical_declaration, line 60, exported)
- `successorSectionMissing` (lexical_declaration, line 67, exported)
- `successorContended` (lexical_declaration, line 74, exported)
- `successorDeclared` (lexical_declaration, line 81, exported)
- `deferVenueMissing` (lexical_declaration, line 90, exported)
- `defersAlready` (lexical_declaration, line 98, exported)
- `defersNothing` (lexical_declaration, line 109, exported)
- `receiverUnknown` (lexical_declaration, line 120, exported)
- `clauseTaken` (lexical_declaration, line 128, exported)
- `clauseDeferred` (lexical_declaration, line 135, exported)
- `retractVenueMissing` (lexical_declaration, line 144, exported)
- `retractSectionMissing` (lexical_declaration, line 148, exported)
- `retractClauseMissing` (lexical_declaration, line 152, exported)
- `clauseRetracted` (lexical_declaration, line 156, exported)
- `arrivePredecessorMissing` (lexical_declaration, line 166, exported)
- `arriveSuccessorUnraised` (lexical_declaration, line 174, exported)
- `arriveNoInheritedSection` (lexical_declaration, line 178, exported)
- `arrivalHeld` (lexical_declaration, line 182, exported)
- `arrivalSettled` (lexical_declaration, line 190, exported)
- `arriveSectionEmpty` (lexical_declaration, line 194, exported)
- `arrivalContended` (lexical_declaration, line 201, exported)
- `arrived` (lexical_declaration, line 205, exported)
- `rosterNotVenue` (lexical_declaration, line 217, exported)
- `rosterVenueElsewhere` (lexical_declaration, line 221, exported)
- `rosterRegression` (lexical_declaration, line 229, exported)
- `rosterUnchanged` (lexical_declaration, line 237, exported)
- `rosterResolved` (lexical_declaration, line 245, exported)
- `inheritNotVenue` (lexical_declaration, line 252, exported)
- `inheritVenueElsewhere` (lexical_declaration, line 256, exported)
- `inheritSectionMissing` (lexical_declaration, line 260, exported)
- `inheritSectionUnbounded` (lexical_declaration, line 264, exported)
- `inheritUnchanged` (lexical_declaration, line 271, exported)
- `inheritContended` (lexical_declaration, line 275, exported)
- `inheritUpdated` (lexical_declaration, line 279, exported)
- `retireNotPlanning` (lexical_declaration, line 286, exported)
- `retireMissing` (lexical_declaration, line 290, exported)
- `retireNothingDistributed` (lexical_declaration, line 294, exported)
- `retireVenueOpen` (lexical_declaration, line 298, exported)
- `retireLineMissing` (lexical_declaration, line 305, exported)
- `retirePreview` (lexical_declaration, line 309, exported)
- `retireContended` (lexical_declaration, line 316, exported)
- `relocateNotVenue` (lexical_declaration, line 327, exported)
- `relocateDestinationTaken` (lexical_declaration, line 334, exported)
- `relocateSourceMissing` (lexical_declaration, line 338, exported)
- `relocateMismatch` (lexical_declaration, line 342, exported)
- `raiseNotAdmissible` (lexical_declaration, line 359, exported)
- `raiseSuccessorUndeclared` (lexical_declaration, line 366, exported)
- `raiseOrdinalMissing` (lexical_declaration, line 375, exported)
- `raiseDestinationTaken` (lexical_declaration, line 382, exported)
- `raiseUnbound` (lexical_declaration, line 389, exported)
- `succession` (lexical_declaration, line 7, exported)
- `recordContended` (lexical_declaration, line 42, exported)
- `SUCCESSOR_NOT_VENUE` (lexical_declaration, line 53, exported)
- `DEFER_NOT_VENUE` (lexical_declaration, line 88, exported)
- `CLAUSE_IS_RECEIVER` (lexical_declaration, line 116, exported)
- `RETRACT_NOT_VENUE` (lexical_declaration, line 142, exported)
- `ARRIVE_NOT_VENUE` (lexical_declaration, line 163, exported)
- `ARRIVE_NO_SUCCESSOR` (lexical_declaration, line 170, exported)
- `rosterLinesMissing` (lexical_declaration, line 225, exported)
- `rosterContended` (lexical_declaration, line 241, exported)
- `retired` (lexical_declaration, line 320, exported)
- `RELOCATE_ROOT_MISSING` (lexical_declaration, line 331, exported)
- `relocated` (lexical_declaration, line 346, exported)
- `RAISE_AGENDA_MISSING` (lexical_declaration, line 353, exported)
- `RAISE_NOTHING_ADMISSIBLE` (lexical_declaration, line 356, exported)
- `RAISE_TEMPLATE_MISSING` (lexical_declaration, line 373, exported)
- `RAISE_BANNER_MISSING` (lexical_declaration, line 386, exported)
- `RAISE_SPECIMEN_MISSING` (lexical_declaration, line 396, exported)
- `raised` (lexical_declaration, line 399, exported)

## Used by

- [tools/core/runners/venue.runner.ts](https://banes-lab.com/source/coordination/tools/core/runners/venue.runner.ts.md)

## Source

```typescript
export const authorityHeld = function authorityHeld(
    act: string,
    holder: string,
    caller: string,
    succeededFrom: string | null,
): string {
    const succession =
        succeededFrom === null
            ? ""
            : `         The index binds venue management to ${succeededFrom}, which is not active, so it passes to ` +
              "the first active seat in index order.\n";
    return (
        `REFUSED  ${act} is venue management, and ${holder} holds it, not ${caller}. Raising venues, moving ` +
        "questions out of a discussion and writing agenda rows go through one seat, so the schedule has one author. " +
        `Send the request to ${holder}.\n${succession}`
    );
};

export const recordSurfaceMissing = function recordSurfaceMissing(target: string): string {
    return `${target} does not exist, so there is nowhere to add a record`;
};

export const recordExists = function recordExists(agent: string, target: string): string {
    return `CLEAR  ${agent} already has a record on ${target}. Nothing was written.\n`;
};

export const recordTemplateMissing = function recordTemplateMissing(kind: string): string {
    return `the ${kind} template does not exist, so the tool has no field list to build the record from`;
};

export const recordTemplateEmpty = function recordTemplateEmpty(kind: string): string {
    return `the ${kind} template declares no record fields, so the tool has no field list to build the record from`;
};

export const recordAnchorMissing = function recordAnchorMissing(target: string): string {
    return (
        `${target} has no place to add a record (on a venue, the Gate heading; on the board, the last record), so ` +
        "the tool cannot tell where it belongs"
    );
};

export const recordContended = function recordContended(target: string): string {
    return `CONTENDED  ${target} changed between the read and the write, so the record was not added. Run the command again.\n`;
};

export const recordAdded = function recordAdded(agent: string, target: string, fields: readonly string[]): string {
    return (
        `RECORD  A record for ${agent} was added to ${target} with ${String(fields.length)} field(s): ` +
        `${fields.join(", ")}. Each field reads \`—\` until you rewrite it; the fields come from the template.\n`
    );
};

export const SUCCESSOR_NOT_VENUE =
    "a successor is declared on a venue, and this target is not one; the raise reads the declaration from the venue";

export const successorVenueMissing = function successorVenueMissing(target: string): string {
    return `${target} does not exist, so there is no venue to declare a successor for`;
};

export const successorNotPlanned = function successorNotPlanned(invariant: string): string {
    return (
        `${invariant} is not a planned row on the agenda, so the tool will not declare it. A venue for it would take ` +
        "an ordinal the schedule gives to another row. Add the row to the agenda first, then declare the successor"
    );
};

export const successorSectionMissing = function successorSectionMissing(target: string): string {
    return (
        `${target} has no SUCCESSOR section, so the convergence check would not find the declaration there. Restore ` +
        "the section from the venue template"
    );
};

export const successorContended = function successorContended(target: string): string {
    return (
        `CONTENDED  ${target} changed between the read and the write, so the successor was not declared. Run the ` +
        "command again.\n"
    );
};

export const successorDeclared = function successorDeclared(target: string, invariant: string): string {
    return (
        `SUCCESSOR  ${target} now declares that it feeds ${invariant}. The declaration sits outside the template's ` +
        "fenced example, where the convergence check reads it.\n"
    );
};

export const DEFER_NOT_VENUE = "a deferral is a question a venue leaves open, and this target is not a venue";

export const deferVenueMissing = function deferVenueMissing(target: string): string {
    return `${target} does not exist, so there is no venue to defer a question from`;
};

export const deferredSectionMissing = function deferredSectionMissing(target: string, section: string): string {
    return `${target} has no ${section} section. Restore it from the venue template`;
};

export const defersAlready = function defersAlready(target: string, count: number): string {
    return (
        `${target} already defers ${String(count)} question(s), so it cannot also record that it defers nothing. ` +
        "Retract those questions first if none remain open"
    );
};

export const markerContended = function markerContended(target: string): string {
    return `${target} changed between the read and the write, so nothing was written. Run the command again`;
};

export const defersNothing = function defersNothing(target: string): string {
    return (
        `DEFERS NOTHING  ${target} now records that it leaves no question open, as a \`- —\` line in the DEFERRED ` +
        "section, which the convergence check reads as an answer.\n"
    );
};

export const CLAUSE_IS_RECEIVER =
    "the question and its receiver are the same text. Name the seat, venue or planned agenda row that will decide " +
    "the question";

export const receiverUnknown = function receiverUnknown(receiver: string): string {
    return (
        `${receiver} is not a place a question can go. A receiver is an active seat, a venue on disk, or a planned ` +
        "agenda row. A venue keeps every line it receives until it converges, so the tool checks the receiver before " +
        "writing"
    );
};

export const clauseTaken = function clauseTaken(target: string, clause: string): string {
    return (
        `${target} already defers ${clause}. Each question appears once, because the successor venue picks it up ` +
        "by name. Defer a differently named question, or retract the existing one"
    );
};

export const clauseDeferred = function clauseDeferred(clause: string, receiver: string, target: string): string {
    return (
        `DEFERRED  ${clause} → ${receiver} is recorded on ${target}. The receiver picks it up when its venue is ` +
        "raised, or when the arrive command runs.\n"
    );
};

export const RETRACT_NOT_VENUE = "a deferral lives on a venue, and this target is not one";

export const retractVenueMissing = function retractVenueMissing(target: string): string {
    return `${target} does not exist, so there is no question to retract`;
};

export const retractSectionMissing = function retractSectionMissing(target: string, section: string): string {
    return `${target} has no ${section} section, so it defers nothing to retract`;
};

export const retractClauseMissing = function retractClauseMissing(target: string, clause: string): string {
    return `${target} does not defer a question named ${clause}. Retract by the exact name in the DEFERRED section`;
};

export const clauseRetracted = function clauseRetracted(clause: string, target: string): string {
    return (
        `RETRACTED  ${clause} was removed from ${target}. Retract a question only once it has been answered, so the ` +
        "receiver does not look for work that no longer exists.\n"
    );
};

export const ARRIVE_NOT_VENUE =
    "an arrival carries questions from a venue into its successor, so the target has to be the predecessor venue";

export const arrivePredecessorMissing = function arrivePredecessorMissing(predecessor: string): string {
    return `${predecessor} does not exist, so there are no deferred questions and no successor to read`;
};

export const ARRIVE_NO_SUCCESSOR =
    "the predecessor declares no successor (outside the template's fenced example), so the deferred questions " +
    "have nowhere to go. Declare the successor first";

export const arriveSuccessorUnraised = function arriveSuccessorUnraised(name: string): string {
    return `${name} does not exist yet. Raise it first; the raise carries every question deferred at that moment`;
};

export const arriveNoInheritedSection = function arriveNoInheritedSection(name: string): string {
    return `${name} has no inherited section, so the tool cannot tell where arriving questions belong`;
};

export const arrivalHeld = function arrivalHeld(name: string, elsewhere: readonly string[]): string {
    return (
        `HELD  ${String(elsewhere.length)} question(s) stay at their origin because they are addressed to a ` +
        `receiver other than ${name}: ${elsewhere.join(", ")}. Each question goes to the receiver it names, which may ` +
        "be a seat or a later agenda row.\n"
    );
};

export const arrivalSettled = function arrivalSettled(predecessor: string, name: string): string {
    return `SETTLED  Every question ${predecessor} defers to ${name} is already there. Nothing was written.\n`;
};

export const arriveSectionEmpty = function arriveSectionEmpty(name: string): string {
    return (
        `${name} has an inherited section with no questions in it, so the tool has no line to add beside. Re-run ` +
        "the inherit command, which rebuilds the section"
    );
};

export const arrivalContended = function arrivalContended(name: string): string {
    return `CONTENDED  ${name} changed between the read and the write, so nothing was carried. Run the command again.\n`;
};

export const arrived = function arrived(
    count: number,
    predecessor: string,
    name: string,
    clauses: readonly string[],
): string {
    return (
        `ARRIVED  ${String(count)} question(s) were carried from ${predecessor} into ${name}: ` +
        `${clauses.join(", ")}.\n`
    );
};

export const rosterNotVenue = function rosterNotVenue(name: string): string {
    return `${name} is not a venue, so it has no roster`;
};

export const rosterVenueElsewhere = function rosterVenueElsewhere(name: string): string {
    return `${name} is not in the venue folder. Move it there with the relocate command first`;
};

export const rosterLinesMissing = function rosterLinesMissing(name: string): string {
    return `${name} does not have both roster lines (NOT-READ and READ AND AWAITING). Restore them from the venue template`;
};

export const rosterRegression = function rosterRegression(name: string, letters: readonly string[]): string {
    return (
        `the new roster for ${name} would mark ${letters.join(", ")} as unread again, but a seat only moves from ` +
        "unread to read while a venue is open. The READ AND AWAITING line has probably lost a mark; correct it by " +
        "hand, then run the command again"
    );
};

export const rosterUnchanged = function rosterUnchanged(name: string): string {
    return `CLEAR  The roster on ${name} is already up to date. Nothing was written.\n`;
};

export const rosterContended = function rosterContended(name: string): string {
    return `${name} changed between the read and the write, so the roster was not updated. Run the command again`;
};

export const rosterResolved = function rosterResolved(name: string, unread: string, read: string): string {
    return (
        `ROSTER  ${name} now lists ${unread} as unread and ${read} as read. The unread list is the active seats that ` +
        "have not marked the venue; a mark is never removed.\n"
    );
};

export const inheritNotVenue = function inheritNotVenue(name: string): string {
    return `${name} is not a venue, so it has no inherited section`;
};

export const inheritVenueElsewhere = function inheritVenueElsewhere(name: string): string {
    return `${name} is not in the venue folder. Move it there with the relocate command first`;
};

export const inheritSectionMissing = function inheritSectionMissing(name: string): string {
    return `${name} has no inherited section. This command updates that section and does not create one`;
};

export const inheritSectionUnbounded = function inheritSectionUnbounded(name: string): string {
    return (
        `${name} has an inherited section with no PROTOCOL banner after it, so the tool cannot tell where the ` +
        "section ends. Restore the banner from the venue template"
    );
};

export const inheritUnchanged = function inheritUnchanged(name: string): string {
    return `CLEAR  The inherited section of ${name} is already up to date. Nothing was written.\n`;
};

export const inheritContended = function inheritContended(name: string): string {
    return `${name} changed between the read and the write, so the inherited section was not updated. Run the command again`;
};

export const inheritUpdated = function inheritUpdated(name: string, count: number, sources: string): string {
    return (
        `INHERITED  ${name} now carries ${String(count)} question(s) from ${sources}. Only the inherited section ` +
        "changed; every record and position below it is as its author wrote it.\n"
    );
};

export const retireNotPlanning = function retireNotPlanning(name: string): string {
    return `${name} is not a planning surface (a .checklist.md file), and this command retires only planning surfaces`;
};

export const retireMissing = function retireMissing(source: string): string {
    return `${source} does not exist`;
};

export const retireNothingDistributed = function retireNothingDistributed(source: string): string {
    return `${source} does not distribute a venue, so there is nothing to retire`;
};

export const retireVenueOpen = function retireVenueOpen(source: string, venue: string): string {
    return (
        `${source} distributes ${venue}, which is still open. Its rows track whether that venue's outcome gets ` +
        "built, so it is retired only after the venue has moved to the archive"
    );
};

export const retireLineMissing = function retireLineMissing(source: string): string {
    return `${source} has no DISTRIBUTES line to replace`;
};

export const retirePreview = function retirePreview(source: string, venue: string): string {
    return (
        `PREVIEW  ${source} would have its DISTRIBUTES line for ${venue} replaced by a RETIRED statement. Nothing ` +
        "else would change, and nothing was written.\n"
    );
};

export const retireContended = function retireContended(source: string): string {
    return `${source} changed between the read and the write, so nothing was written. Run the command again`;
};

export const retired = function retired(source: string): string {
    return (
        `RETIRED  ${source} no longer distributes a venue, and the file stays where it is. It is edited rather than ` +
        "moved, because archived venues cite it by path and an archived file can no longer be updated.\n"
    );
};

export const relocateNotVenue = function relocateNotVenue(name: string): string {
    return `${name} is not a venue, and this command moves only venues`;
};

export const RELOCATE_ROOT_MISSING =
    "the venue folder does not exist, so there is nowhere to move the venue to. Check the package's root setting";

export const relocateDestinationTaken = function relocateDestinationTaken(name: string): string {
    return `${name} is already in the venue folder, so there is nothing to move`;
};

export const relocateSourceMissing = function relocateSourceMissing(name: string): string {
    return `${name} is in neither the venue folder nor the project root, so there is nothing to move`;
};

export const relocateMismatch = function relocateMismatch(name: string): string {
    return `${name} did not arrive unchanged, so the original was left in place`;
};

export const relocated = function relocated(name: string): string {
    return (
        `RELOCATED  ${name} was moved from the project root into the venue folder, unchanged. The copy was checked ` +
        "before the original was removed.\n"
    );
};

export const RAISE_AGENDA_MISSING =
    "the agenda does not exist, so the tool has no schedule to decide which venue comes next";

export const RAISE_NOTHING_ADMISSIBLE =
    "the agenda has no planned row without a venue, so there is nothing to raise. Add the row to the agenda first";

export const raiseNotAdmissible = function raiseNotAdmissible(named: string, admissible: readonly string[]): string {
    return (
        `${named} cannot be raised now: the agenda does not carry it as planned, or a venue for it already exists. ` +
        `Rows that can be raised: ${admissible.join(", ")}`
    );
};

export const raiseSuccessorUndeclared = function raiseSuccessorUndeclared(undeclared: readonly string[]): string {
    return (
        `${undeclared.join(", ")} declares no successor. Declare it on the open venue before raising, because the ` +
        "raise moves the agenda row out of the planned state and the declaration is refused after that"
    );
};

export const RAISE_TEMPLATE_MISSING = "the venue template does not exist, so there is nothing to build the venue from";

export const raiseOrdinalMissing = function raiseOrdinalMissing(invariant: string): string {
    return (
        `the agenda row for ${invariant} has no ordinal, and the venue's filename takes its number from that cell. ` +
        "Fill in the ordinal, then raise"
    );
};

export const raiseDestinationTaken = function raiseDestinationTaken(name: string): string {
    return `${name} already exists, so the raise would overwrite a venue. Nothing was written`;
};

export const RAISE_BANNER_MISSING =
    "the venue template has no PROTOCOL banner, so the tool cannot tell where the inherited section goes";

export const raiseUnbound = function raiseUnbound(unbound: readonly string[]): string {
    return (
        `${unbound.join(", ")} has no row in the agent index, so a record under that letter would point to no ` +
        'role. Add the row with `--index "<role>"`, then raise'
    );
};

export const RAISE_SPECIMEN_MISSING =
    "the venue template has no fenced example record, so the tool has no shape to build each participant's record from";

export const raised = function raised(
    name: string,
    participants: readonly string[],
    clauses: number,
    sources: string,
): string {
    return (
        `RAISED  ${name} was created from the template at the position the agenda gives it. It seats ` +
        `${participants.join(", ")}, each with an empty record, and carries ${String(clauses)} inherited ` +
        `question(s) from ${sources}. Every seat starts as unread; a seat marks the venue as read once the previous ` +
        "venue has left the active folder. Fill in your record before posting a position.\n"
    );
};
```