# tools/core/strings/pipeline.strings.ts

> 88 lines of code and 17 definitions.

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

## Definitions

- `healingHeld` (lexical_declaration, line 5, exported)
- `covered` (lexical_declaration, line 17, exported)
- `wroteOutsideScope` (lexical_declaration, line 24, exported)
- `claimedUnwritten` (lexical_declaration, line 31, exported)
- `scopeUnresolved` (lexical_declaration, line 38, exported)
- `repairedWhileReading` (lexical_declaration, line 47, exported)
- `runContended` (lexical_declaration, line 55, exported)
- `narrowedRun` (lexical_declaration, line 62, exported)
- `notMeasured` (lexical_declaration, line 69, exported)
- `joinedResult` (lexical_declaration, line 87, exported)
- `UNATTRIBUTED` (lexical_declaration, line 1, exported)
- `JOINED` (lexical_declaration, line 13, exported)
- `BYPASSED_RUN` (lexical_declaration, line 45, exported)
- `JoinedRun` (interface_declaration, line 80, exported)
- `JOIN_ABANDONED` (lexical_declaration, line 94, exported)
- `SUPERSEDED` (lexical_declaration, line 98, exported)
- `STREAMED` (lexical_declaration, line 102, exported)

## Used by

- [tools/core/entrypoints/pipeline.entrypoint.ts](https://banes-lab.com/source/coordination/tools/core/entrypoints/pipeline.entrypoint.ts.md)
- [tools/core/reporters/rule.reporter.ts](https://banes-lab.com/source/coordination/tools/core/reporters/rule.reporter.ts.md)

## Source

```typescript
export const UNATTRIBUTED =
    "UNATTRIBUTED  This run names no caller, so its report and its claim on the tree name nobody a peer can ask. " +
    "Pass --agent <LETTER> to attribute it. The run continues.\n";

export const healingHeld = function healingHeld(count: number, runs: readonly string[]): string {
    return (
        `HEALING HELD  ${String(count)} live run(s) write files this run would also write: ${runs.join("; ")}. ` +
        "This run reports and repairs nothing, so neither run overwrites the other. Run it again once the other " +
        "run has finished to get the repairs.\n"
    );
};

export const JOINED =
    "JOINED  A run that started earlier is measuring the same files, so this run does not measure them again. It " +
    "wrote no report and released its claim. The result below is the earlier run's.\n";

export const covered = function covered(count: number, runs: readonly string[]): string {
    return (
        `COVERED  ${String(count)} live run(s) already measure this scope: ${runs.join("; ")}. This run wrote ` +
        "nothing and released its claim. The result below is the covering run's, printed once it is published.\n"
    );
};

export const wroteOutsideScope = function wroteOutsideScope(paths: readonly string[]): string {
    return (
        `WROTE OUTSIDE ITS SCOPE  ${paths.join(", ")}. This run wrote files outside the scope it declared, so a ` +
        "peer that stayed clear of that scope was not protected from it.\n"
    );
};

export const claimedUnwritten = function claimedUnwritten(paths: readonly string[]): string {
    return (
        `CLAIMED A WRITE THAT DID NOT HAPPEN  ${paths.join(", ")}. The run reports repairing these files, and ` +
        "their contents did not change.\n"
    );
};

export const scopeUnresolved = function scopeUnresolved(scope: string): string {
    return (
        `REFUSED  The scope ${scope} matches no path, so this run measured nothing and wrote no report. A scope is ` +
        "resolved from the project root, so include any folder prefix in the path.\n"
    );
};

export const BYPASSED_RUN = "A run that bypassed a check does not count as a complete run.\n";

export const repairedWhileReading = function repairedWhileReading(paths: readonly string[]): string {
    return (
        `REPAIRED WHILE READING  ${paths.join(", ")}. These files changed because this run repaired them, so they ` +
        "do not make the verdict contended. A file this run repaired and a peer also wrote cannot be told apart " +
        "from one only this run repaired.\n"
    );
};

export const runContended = function runContended(count: number, paths: readonly string[]): string {
    return (
        `CONTENDED  ${String(count)} file(s) changed while this run was reading, so the verdict is not ` +
        `authoritative. Run it again once the other write has finished: ${paths.join(", ")}\n`
    );
};

export const narrowedRun = function narrowedRun(scope: string, aggregate: string): string {
    return (
        `Narrowed run (scope=${scope}): this result is printed only. ${aggregate} still holds the last full run ` +
        "and remains the only report.\n"
    );
};

export const notMeasured = function notMeasured(rules: readonly string[]): string {
    return (
        `NOT MEASURED  ${rules.join(", ")}. A narrowed run skips these checks for one of three reasons:\n` +
        "  - the check reads its subjects from a declared list and its evidence from the scanned files, so a " +
        "narrowed scope would remove the evidence and report false failures;\n" +
        "  - the check reads a fixed population outside this scope, so its result would not describe this scope;\n" +
        "  - the check deletes files from a list the scope does not limit.\n" +
        "Run the full scope to measure them.\n"
    );
};

export interface JoinedRun {
    readonly verdict: string;
    readonly scope: string;
    readonly agent: string;
    readonly findings: number;
}

export const joinedResult = function joinedResult(run: JoinedRun, report: string): string {
    return (
        `${run.verdict.toUpperCase()}  The joined run has published: scope ${run.scope}, run by ${run.agent}, ` +
        `${String(run.findings)} finding(s). This is that run's result. Details are in ${report}.\n`
    );
};

export const JOIN_ABANDONED =
    "ABANDONED  The joined run did not publish within the join window, so there is no result to show. It may " +
    "have stopped; the next run removes its claim and measures the tree itself.\n";

export const SUPERSEDED =
    "SUPERSEDED  The report on disk comes from a run that started after this one, so this result is printed and " +
    "not written. An older result never replaces a newer one.\n";

export const STREAMED =
    "STREAMED  This result is printed and not written. Only a full-scope run writes the report, so the report on " +
    "disk still holds the last full run.\n";
```