# configuration/strings/release.fragment.strings.ts

> 70 lines of code and 3 definitions.

Tree: Site tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/tree#file-configuration-strings-release-fragment-strings-ts
Source text: https://banes-lab.com/assets/sources/source.32b3ba27eb1f0912ff28833680eedec0a606f58b4725cea236b2aa0124d05a76.generated.txt

## Definitions

- `PROXY_DIAGRAM` (lexical_declaration, line 6)
- `RETIRED_SECTION` (lexical_declaration, line 9, exported)
- `GAP_SECTION` (lexical_declaration, line 39, exported)

## Source

```typescript
import { GAP_SECTION_ICON, RETIRED_SECTION_ICON } from "#configuration/icons/release.icons";
import { GAP_SECTION_ID, RETIRED_SECTION_ID } from "#core/ids/release.ids";
import type { Section } from "#types/document.types";
import { nodeLink as node } from "#domain/converters/link.converter";

const PROXY_DIAGRAM =
    'flowchart TB\n    subgraph proxies["The proxy rule"]\n        r1["Benchmark everything before any application logic"]\n        r2["Synchronous over asynchronous, always"]\n    end\n    subgraph properties["The property it stands for"]\n        p1["A measurement precedes an optimisation"]\n        p2["One correct answer exists"]\n    end\n    subgraph holds["What holds the property"]\n        h1["Measure a hot path when you have one, never as a rite"]\n        h2["Asynchronous by necessity, still one correct answer"]\n    end\n    r1 --> p1 --> h1\n    r2 --> p2 --> h2';

export const RETIRED_SECTION: Section = {
    icon: RETIRED_SECTION_ICON,
    id: RETIRED_SECTION_ID,
    intro: "A rule that stands in for a property is a proxy. A proxy is easy to state and easy to enforce for its own sake, and it ends up guarding the wrong thing; the ontology's names for the habit are pattern cargo cult and golden hammer. Two proxies come up often enough to name here, and <cite>two proxies</cite> shows each one with the property it stands for and what holds that property instead. Two others are retired elsewhere in the method: a fixed line count repeated in every document is retired in one home, and a voice the model keeps up all session is retired in a seat is a contract.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, the question for every rule is what property it protects, and that property is named.",
                    cause: "A proxy is easier to state than the property, so it gets stated first and then outlives its reason.",
                    decision:
                        "The property is checked directly and the proxy is let go, rather than the rule being kept beside the check.",
                    failureMode:
                        "The team argues about whether a file may have one more line, while the module it lives in has no boundary at all.",
                    kind: "lesson",
                    principle:
                        "For this reason a rule that stands in for a property gives way once the property has a check.",
                    problem: "A rule that outlives its reason gets enforced for its own sake.",
                    validation:
                        "To check this, stop enforcing one rule for a cycle. If the property it stood for still holds, the rule was the proxy.",
                },
                { caption: "two proxies", kind: "mermaid", text: PROXY_DIAGRAM },
            ],
            title: "The property behind the rule",
        },
    ],
    title: "Proxies give way",
};

export const GAP_SECTION: Section = {
    icon: GAP_SECTION_ICON,
    id: GAP_SECTION_ID,
    intro: `Some things this method does not do. Nothing computes worth: the ${node("tel-utility", "utility")} and ${node("tel-cost", "cost")} nodes of the ontology's teleology axis are empty slots here, and I make that decision myself. Nothing detects a lack of progress; ${node("ter-diminishing-returns", "diminishing returns")} is a node I notice rather than a detector that fires. ${node("ver-confidence", "Confidence")} is a threshold rather than a distribution, and several conduct rules have no artifact behind them yet. I state these gaps because a method that claims to be complete is one whose gaps you find in production. The architecture page keeps its own list of the same kind, where each gap is declared absent and never assumed.`,
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, a list is kept of the guarantees the method claims, and each is marked as held, derived or absent.",
                    cause: "A guarantee that nothing provides gets assumed by the developer or the model who needs it, and the assumption never fails where it began.",
                    decision: "An absence is declared in the adapter rather than filled with a default in the core.",
                    failureMode:
                        "The method reads as complete, a reader relies on a guarantee it never gave, and the reader finds out where it matters most.",
                    kind: "lesson",
                    principle:
                        "For this reason an absence is measured and declared, rather than left for you or the model to infer or cover over.",
                    problem: "A method that hides its gaps hands them to the reader unannounced.",
                    validation:
                        "To check this, read the declared absences; each should name what would fill it. A method with no declared absences has stopped looking for them.",
                },
                {
                    kind: "text",
                    text: "The absences are named in the adapter as slots that nothing fills. Whether a task is worth doing is a decision I make with a sentence written before the work, and no mechanism computes utility against cost across the options. No step compares a previous render with a fresh one, so the generators overwrite unconditionally and the drift check is the only signal of a fixed point. The gate has no detector for a run that thrashes, so it runs every step every time and cannot tell a converging run from an oscillating one. A claim passes or fails a threshold, and nothing carries a distribution of how sure the verifier is. No registry entry carries its own test of whether it applies, so every composition iterates over everything. Finally, no predicate compares a number written in prose against a real count, because prose carries no count and the predicate would have nothing to check.",
                },
                {
                    kind: "text",
                    text: "The naming standard is enforced. The reasoning ontology's epistemic and structural predicates run, and its conative layer is the gap described above, which the architecture page reads from its own side. An absence is measured before it is reported, just as a negative result is, as described in a report, not a checkbox. From inside a tree, a capability that nothing calls and one that does not exist look the same.",
                },
            ],
            title: "Declared absences",
        },
    ],
    title: "The honest gaps",
};
```