# tools/core/runners/collapse.runner.ts

> 99 lines of code and 16 definitions.

Tree: Coordination tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-tools-core-runners-collapse-runner-ts
Source text: https://banes-lab.com/source/coordination/tools/core/runners/collapse.runner.ts.txt

Listed in [tools/core/runners](https://banes-lab.com/api/source/coordination/tools/core/runners.md), after [tools/core/runners/checklist.runner.ts](https://banes-lab.com/source/coordination/tools/core/runners/checklist.runner.ts.md) and before [tools/core/runners/conduct.runner.ts](https://banes-lab.com/source/coordination/tools/core/runners/conduct.runner.ts.md).

## Definitions

- `runCompression` (lexical_declaration, line 91, exported)
- `dropItem` (lexical_declaration, line 32)
- `compressFields` (lexical_declaration, line 53)
- `CompressRequest` (interface_declaration, line 21)
- `dropped` (lexical_declaration, line 33)
- `span` (lexical_declaration, line 59)
- `lines` (lexical_declaration, line 64)
- `body` (lexical_declaration, line 65)
- `schemaField` (lexical_declaration, line 66)
- `compressed` (lexical_declaration, line 67)
- `text` (lexical_declaration, line 72)
- `outcome` (lexical_declaration, line 73)
- `{ agent }` (lexical_declaration, line 96, exported)
- `carried` (lexical_declaration, line 101, exported)
- `refusal` (lexical_declaration, line 102, exported)
- `before` (lexical_declaration, line 107, exported)

## Uses

- [tools/core/formatters/board.formatter.ts](https://banes-lab.com/source/coordination/tools/core/formatters/board.formatter.ts.md)
- [tools/core/strings/board.strings.ts](https://banes-lab.com/source/coordination/tools/core/strings/board.strings.ts.md)
- [tools/core/writers/board.writer.ts](https://banes-lab.com/source/coordination/tools/core/writers/board.writer.ts.md)

## Used by

- [tools/core/coordinators/collapse.coordinator.ts](https://banes-lab.com/source/coordination/tools/core/coordinators/collapse.coordinator.ts.md)

## Source

```typescript
import {
    COMPRESS_NEEDS_AGENT,
    compressionNoRecord,
    fieldEmptied,
    fieldsCompressed,
    itemDropped,
    itemFenceMalformed,
    noMarkedField,
    nothingToCompress,
    surfaceContended,
} from "../strings/board.strings.ts";
import { blockOf, compressBoard } from "../transformers/board.transformer.ts";
import { existsSync, readFileSync, writeFileSync } from "node:fs";
import { landWitnessed, refuse } from "../writers/board.writer.ts";
import type { CompressOutcome } from "../types/board.types.ts";
import { dropItemSpan } from "../resolvers/board.resolver.ts";
import { extractionRefusal } from "../validators/archive.validator.ts";
import { fieldKeyAt } from "../analyzers/board.analyzer.ts";
import { isItemId } from "../formatters/board.formatter.ts";

interface CompressRequest {
    readonly target: string;
    readonly absolute: string;
    readonly marker: string;
    readonly agent: string | null;
    readonly extracted: string | null;
    readonly archive: string;
    readonly changelog: string;
    readonly heal: boolean;
}

const dropItem = function dropItem(request: CompressRequest, before: string): CompressOutcome {
    const dropped = dropItemSpan(before, request.marker);
    if (dropped === null) {
        return refuse(itemFenceMalformed(request.marker), 2);
    }

    if (request.heal) {
        if (readFileSync(request.absolute, "utf8") !== before) {
            return refuse(surfaceContended(request.target), 1);
        }
        writeFileSync(request.absolute, dropped.text, "utf8");
    }

    return {
        code: 0,
        excised: [request.marker],
        message: itemDropped(request.marker, dropped.removed, request.heal),
        write: request.heal ? dropped.text : null,
    };
};

const compressFields = function compressFields(
    request: CompressRequest,
    agent: string,
    before: string,
    retry: () => CompressOutcome,
): CompressOutcome {
    const span = blockOf(before, agent);
    if (span === null) {
        return refuse(compressionNoRecord(agent), 2);
    }

    const lines = before.split("\n");
    const body = lines.slice(span.from, span.to - 1);
    const schemaField = body.some((line) => fieldKeyAt(line) === request.marker);
    const compressed = compressBoard(body.join("\n"), request.marker, schemaField);
    if (compressed.fields === 0) {
        return refuse(noMarkedField(request.target), 0);
    }

    const text = [...lines.slice(0, span.from), compressed.text, ...lines.slice(span.to - 1)].join("\n");
    const outcome = {
        code: 0,
        excised: compressed.excised,
        message: schemaField
            ? fieldEmptied(request.marker, request.target, compressed.removed, request.heal)
            : fieldsCompressed(request.target, compressed.fields, compressed.removed, request.heal),
        write: request.heal ? text : null,
    };

    return request.heal
        ? landWitnessed(
              { absolute: request.absolute, agent, before, target: request.target, written: text },
              outcome,
              retry,
          )
        : outcome;
};

export const runCompression = function runCompression(request: CompressRequest): CompressOutcome {
    if (!existsSync(request.absolute)) {
        return refuse(nothingToCompress(request.target), 2);
    }

    const { agent } = request;
    if (agent === null) {
        return refuse(COMPRESS_NEEDS_AGENT, 2);
    }

    const carried = existsSync(request.archive) ? readFileSync(request.archive, "utf8") : "";
    const refusal = extractionRefusal(request.changelog, request.extracted, carried);
    if (refusal !== null) {
        return refuse(refusal, 2);
    }

    const before = readFileSync(request.absolute, "utf8");
    return isItemId(request.marker)
        ? dropItem(request, before)
        : compressFields(request, agent, before, () => runCompression({ ...request }));
};
```