@holmes-lab/holmes-kit 0.1.7 → 0.1.8

package/dist/holmes/mcp/handlers.d.ts

@@ -0,0 +1,482 @@
+import { SpecStore } from '../spec/spec-store';
+import { Action } from '../guardrail/phase';
+import { Basis } from './basis';
+import { Finding } from '../review/findings';
+import { Approval, Enforcement } from '../guardrail/risk-gate';
+import { RiskAction } from '../guardrail/risk-types';
+/**
+ * @implements A-SPEC-189 §7 (round 10)
+ * A DELIBERATE refusal, distinguished by construction rather than by class.
+ *
+ * Round 9 converted thrown errors into `{ok:false, reason}` at the wire and told them apart with
+ * `e.constructor === Error`. Measured: Node's own fs/exec failures (ENOENT, EISDIR, EACCES) are
+ * exactly `Error`, so a CRASH became an orderly refusal — and for `review_status` that refusal had
+ * no `blocked` field at all, i.e. a gate reader's `if (out.blocked)` read undefined and passed.
+ * The check that used to stop the caller loudly (-32603) became a silent gate pass. A refusal is
+ * something a handler chooses to say; nothing infers it from a class.
+ */
+export declare class HandlerRefusal extends Error {
+    readonly holmesRefusal = true;
+    constructor(message: string);
+}
+/** Marker test that survives realm boundaries (jest's instanceof does not). */
+export declare function isHandlerRefusal(e: unknown): e is Error;
+import { ChangeSourceInfo } from '../project/change-source';
+import { DraftResult } from '../reverse/draft';
+import { AnchorMapping } from '../reverse/anchor';
+/**
+ * @implements A-SPEC-156
+ * Basis is attached HERE, in one place, rather than inside each handler. Measured reasoning: 25
+ * handlers edited by hand is 25 chances to forget, and the one that forgets is invisible — which is
+ * precisely how the surface came to answer confidently with nothing backing it. The coverage test
+ * walks the tool list for the same reason.
+ */
+export declare function makeHandlers(store: SpecStore): RawHandlers & {
+    basis_detail(a: {
+        root?: string;
+    }): Promise<Basis & {
+        basis: string;
+    }>;
+};
+type RawHandlers = ReturnType<typeof makeRawHandlers>;
+declare function makeRawHandlers(store: SpecStore): {
+    spec_create(a: any): Promise<{
+        ok: boolean;
+        reason: string;
+        created?: undefined;
+    } | {
+        created: any;
+        ok?: undefined;
+        reason?: undefined;
+    }>;
+    spec_validate(a: any): Promise<{
+        ok: boolean;
+        findings: {
+            level: string;
+            code: string;
+            message: any;
+        }[];
+    }>;
+    /**
+     * @implements A-SPEC-132
+     * Approval as an ACT: validate → seal → flip → ledger, in one call. This is the designed
+     * reversal of "no approval tool exists" (which promote-slice documented while it was true) —
+     * the act now includes digest computation a hand edit cannot perform honestly. Fail-closed on
+     * the SERVER-environment approval: nothing in the request payload can substitute, because the
+     * agent authors the payload and the operator authors the environment.
+     */
+    /**
+     * @implements A-SPEC-184
+     * Raise ONE named document from an older spec format to the current one.
+     *
+     * The compatibility policy this implements: older documents are read and left alone by default,
+     * and rise only when a human points at the one they intend to use. There is deliberately no bulk
+     * path — 155 documents here and 90 in the measured adoption target, and which of them are still
+     * live specifications is a judgement only a person holds.
+     *
+     * It declares a KIND. It does not confer approval: 37 of this repository's legacy documents read
+     * `status: Approved`, and carrying that across would mint approvals that never passed the sealing
+     * act. The old value is preserved as evidence and the document restarts at `draft`.
+     *
+     * Takes no `root`: the store is bound at server construction, exactly as `spec_create` is.
+     */
+    spec_upgrade(a: {
+        id: string;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        upgraded?: undefined;
+        type?: undefined;
+        legacyStatus?: undefined;
+        remaining?: undefined;
+    } | {
+        ok: boolean;
+        upgraded: boolean;
+        reason: string;
+        type?: undefined;
+        legacyStatus?: undefined;
+        remaining?: undefined;
+    } | {
+        ok: boolean;
+        upgraded: boolean;
+        type: import("../spec/spec-types").SpecType;
+        legacyStatus: string;
+        remaining: import("../spec/validator").Finding[];
+        reason?: undefined;
+    }>;
+    spec_approve(a: {
+        root?: string;
+        id: string;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        findings?: undefined;
+        approved?: undefined;
+        digest?: undefined;
+    } | {
+        ok: boolean;
+        reason: string;
+        findings: import("../spec/validator").Finding[];
+        approved?: undefined;
+        digest?: undefined;
+    } | {
+        approved: string;
+        digest: string;
+        ok?: undefined;
+        reason?: undefined;
+        findings?: undefined;
+    }>;
+    spec_list(a: any): Promise<{
+        specs: {
+            legacy?: boolean | undefined;
+            parent?: string | undefined;
+            id: string;
+            type: import("../spec/spec-types").SpecType;
+            status: "draft" | "review" | "approved" | "outdated";
+        }[];
+    }>;
+    spec_next(): Promise<{
+        next: import("../spec/spec-types").SpecType;
+    } | {
+        next: null;
+    }>;
+    rtm_check(a?: {
+        root?: string;
+    }): Promise<{
+        issues: import("../rtm/rtm-check").RtmIssue[];
+        gaps: import("../rtm/gap-analyzer").ConvergenceGaps;
+        breakingChangeDistribution: Record<string, number>;
+    } | {
+        issues: import("../rtm/rtm-check").RtmIssue[];
+        breakingChangeDistribution: Record<string, number>;
+        gaps?: undefined;
+    }>;
+    /**
+     * Pin a REQ's citations: compute the content digest of every cited source that resolves inside
+     * the repo and record it as `rev`, so an author never hashes a file by hand and the digest is
+     * always derived from what is actually on disk.
+     *
+     * Explicit-invocation only, dry-run by DEFAULT, and never overwrites an existing digest — a
+     * re-pin would replace evidence of upstream drift with a fresh-looking value, converting the
+     * detector into a concealer.
+     */
+    citation_pin(a: {
+        root: string;
+        id: string;
+        dryRun?: boolean;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        id?: undefined;
+        dryRun?: undefined;
+        pinned?: undefined;
+        findings?: undefined;
+        citations?: undefined;
+    } | {
+        ok: boolean;
+        id: string;
+        dryRun: boolean;
+        pinned: string[];
+        findings: import("../spec/validator").Finding[];
+        citations: unknown[];
+        reason?: undefined;
+    }>;
+    phase_status(a: {
+        root?: string;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        specs?: undefined;
+        note?: undefined;
+    } | {
+        specs: {
+            id: string;
+            type: import("../spec/spec-types").SpecType;
+            status: "draft" | "review" | "approved" | "outdated";
+        }[];
+        note: string;
+        ok?: undefined;
+        reason?: undefined;
+    }>;
+    phase_check(a: {
+        action?: Action;
+        target: string;
+        targetAspecId?: string;
+    }): Promise<import("../guardrail/phase").CheckResult | {
+        decision: string;
+        note: string;
+    }>;
+    cpg_scan(a: {
+        root: string;
+    }): Promise<{
+        files: number;
+        symbols: number;
+        skipped: {
+            file: string;
+            reason: string;
+        }[];
+        skippedCount: number;
+    }>;
+    /**
+     * @implements A-SPEC-138
+     * Call-graph taint REACHABILITY screen: source-named functions that reach sink-named functions
+     * through call edges. A SCREENING signal that routes a security review, NOT a data-flow proof —
+     * the result always carries the honesty envelope (kind + limits) and phrases pairs as "reaches",
+     * never "vulnerable".
+     */
+    taint_scan(a: {
+        root: string;
+    }): Promise<{
+        kind: string;
+        limits: ("name-based matching" | "no def-use" | "no sanitizers" | "call-edge-only")[];
+        maxPaths: number | undefined;
+        truncated: number;
+        pairs: import("../rtm/taint").TaintPair[];
+    }>;
+    test_run(a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+        mark?: string;
+    }): Promise<{
+        baselineRecorded?: string | undefined;
+        scopeFallback?: "full" | undefined;
+        tier: import("../rtm/test-scope").RegressionTier;
+        mode: "full" | "scoped" | "noop";
+        passed: boolean;
+        skipped: boolean;
+        ranFiles: string[];
+        executedByAspec: Record<string, number>;
+        tail: string;
+        unresolvedFiles: string[];
+        changeSource: ChangeSourceInfo;
+    }>;
+    issue_localize(a: {
+        root: string;
+        issue: string;
+        topN?: number;
+    }): Promise<import("../rtm/localize").LocalizationReport>;
+    rtm_impact(a: {
+        root: string;
+        changed: string[];
+    }): Promise<{
+        breadthWarning?: string | undefined;
+        impacted: string[];
+        reachedByDepth: number[];
+        bounded: {
+            id: string;
+            reason: "hub" | "depth";
+            inDegree?: number;
+        }[] | undefined;
+    }>;
+    rtm_reindex(a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+    }): Promise<{
+        changed: number;
+        nodes: number;
+        edges: number;
+        changeSource: ChangeSourceInfo;
+    }>;
+    context_bundle(a: {
+        root: string;
+        seedId: string;
+        budget: number;
+    }): Promise<import("../context/bundler").ContextBundle>;
+    review_scope(a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+    }): Promise<{
+        scopeFallback?: "full" | undefined;
+        unscannedChangedFiles: string[];
+        testScope: import("../rtm/test-scope").TestScope;
+        changeSource: ChangeSourceInfo;
+        changedSymbols: string[];
+        impactedSpecs: string[];
+        acceptanceCriteria: Array<{
+            specId: string;
+            criteria: string;
+        }>;
+        unrequestedSymbols: string[];
+        coverageGaps: string[];
+    }>;
+    review_prepare(a: {
+        root: string;
+        base?: string;
+        head?: string;
+        since?: string;
+        budget?: number;
+    }): Promise<{
+        scopeFallback?: "full" | undefined;
+        package: import("../review/package").ReviewPackage;
+        unscannedChangedFiles: string[];
+        changeSource: ChangeSourceInfo;
+    }>;
+    review_record(a: {
+        root: string;
+        findings: Finding[];
+    }): Promise<{
+        recorded: number;
+    }>;
+    review_status(a: {
+        root: string;
+    }): Promise<{
+        blocked: boolean;
+        open: {
+            critical: number;
+            important: number;
+            minor: number;
+        };
+        reviewNeeded: import("../review/review-targets").ReviewNeeded[];
+    }>;
+    risk_check(a: {
+        root?: string;
+        action: RiskAction;
+        approval?: Approval;
+        changedSymbols?: string[];
+        enforcement?: Enforcement;
+        ts: string;
+        actor?: string;
+        rationale?: string;
+    }): Promise<{
+        assessment: import("../guardrail/risk-types").RiskAssessment;
+        gate: import("../guardrail/risk-gate").GateResult;
+    }>;
+    /**
+     * Read-only inventory of a brownfield target: candidate clusters, coverage, and what the scan
+     * could not resolve. Deliberately does NOT call assertRepoTopLevel — a target that is not a git
+     * repository is a supported case here, reported as `isGit: false`.
+     */
+    reverse_scan(a: {
+        root: string;
+        maxFlagged?: number;
+    }): Promise<{
+        root: string;
+        isGit: boolean;
+        scanned: number;
+        droppedUntracked: number;
+        candidates: number;
+        anchored: number;
+        unanchored: number;
+        clusters: import("../reverse/cluster").Cluster[];
+        testClusters: import("../reverse/cluster").Cluster[];
+        coverage: {
+            structurallyResolved: number;
+            inTestClusters: number;
+            cohesionUnmeasured: number;
+            testsMatched: number;
+            testsUnmatched: number;
+            withDynamicIndicators: number;
+            indicators: Partial<Record<import("../reverse/dynamic-wiring").Indicator, number>>;
+            uncalibratedIndicatorLanguages: string[];
+            ignoreUnsupportedPatterns: string[];
+        };
+        needsHumanConfirmation: import("../reverse/scan").FlaggedFile[];
+        tests: import("../reverse/test-map").TestMapping;
+    }>;
+    /**
+     * Draft H-SPEC/A-SPEC/T-SPEC documents for the recovered clusters under an EXISTING parent REQ.
+     *
+     * The REQ is the human's to write and this tool refuses without one — a requirement states
+     * business intent, which is not in the code. Everything emitted is `status: draft`, and writing
+     * requires an explicit `dryRun: false`.
+     *
+     * WHERE THE DOCUMENTS LAND: in the SERVER's configured spec store (`HOLMES_SPECS`, default
+     * `.ax/specs` relative to the server's working directory) — not inside `root`. In the intended
+     * adoption the two are the same directory, because the server runs inside the target it governs;
+     * pointing `root` at a different repository drafts that repository's slices into THIS store,
+     * which is a governance decision the caller has to make deliberately.
+     */
+    reverse_draft(a: {
+        root: string;
+        parentReqId?: string;
+        cluster?: string;
+        dryRun?: boolean;
+    }): Promise<{
+        ok: boolean;
+        reason: string;
+        availableClusters?: undefined;
+        dryRun?: undefined;
+        parentReqId?: undefined;
+        clusters?: undefined;
+        drafted?: undefined;
+        skipped?: undefined;
+        refused?: undefined;
+    } | {
+        ok: boolean;
+        reason: string;
+        availableClusters: string[];
+        dryRun?: undefined;
+        parentReqId?: undefined;
+        clusters?: undefined;
+        drafted?: undefined;
+        skipped?: undefined;
+        refused?: undefined;
+    } | {
+        ok: boolean;
+        dryRun: boolean;
+        parentReqId: string;
+        clusters: number;
+        drafted: DraftResult[];
+        skipped: {
+            clusterKey: string;
+            reason: string;
+        }[];
+        refused: {
+            clusterKey: string;
+            reason: string;
+            findings?: unknown[];
+        }[];
+        reason?: undefined;
+        availableClusters?: undefined;
+    }>;
+    /**
+     * Insert `@implements` anchors into source files. Dry-run by DEFAULT, and anchoring to a
+     * non-approved A-SPEC is refused — a reverse-engineered draft describes code; description does
+     * not confer approval.
+     */
+    reverse_anchor(a: {
+        root: string;
+        mapping: AnchorMapping[];
+        dryRun?: boolean;
+    }): Promise<{
+        blockers: Record<string, string>;
+        applied: number;
+        dryRun: boolean;
+        would: number;
+        failed: import("../reverse/anchor").RefusedAnchor[];
+        edits: import("../reverse/anchor").AnchorEdit[];
+        refused: import("../reverse/anchor").RefusedAnchor[];
+    }>;
+    spec_slice_init(a: {
+        root?: string;
+        sliceName: string;
+        title: string;
+        objective: string;
+        filesToTouch: string[];
+    }): Promise<{
+        ok: boolean;
+        specsCreated: string[];
+    }>;
+    spec_slice_approve(a: {
+        root?: string;
+        sliceName: string;
+    }): Promise<{
+        ok: boolean;
+        approvedSpecs: string[];
+    }>;
+    spec_remediate(a: {
+        root?: string;
+        targetFile?: string;
+        aspecId?: string;
+    }): Promise<{
+        ok: boolean;
+        actionsTaken: string[];
+    }>;
+};
+export {};

package/dist/holmes/mcp/server.d.ts

@@ -0,0 +1,2 @@
+import { HOOK_ENFORCED_TOOLS } from './tool-schemas';
+export { HOOK_ENFORCED_TOOLS };

package/dist/holmes/mcp/stdio-client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Keys excluded from surface comparison.
+ *
+ * `basis` legitimately differs: two processes observe the world at different moments, so the spec
+ * fingerprint can move between the two calls. Excluding it is correct — but the exclusion is named
+ * and asserted, because an agreement claim whose exceptions are invisible is stronger-sounding than
+ * it is.
+ */
+export declare const OMITTED_FROM_COMPARISON: readonly ["basis"];
+/** Strips the excluded keys so two answers can be compared for the part that must match. */
+export declare function comparable(v: unknown): unknown;
+/**
+ * Extracts a tool's payload from an MCP result.
+ *
+ * Pure and exported because the failure it guards — a surface that answers with no text at all —
+ * cannot be produced by the real server (an unknown tool comes back as a perfectly well-formed
+ * `{"error":"unknown tool"}`), so the branch is unreachable from an end-to-end test. Left inline it
+ * would be an untested guard, and an untested guard is one a later change deletes for free: with it
+ * gone, a silent surface yields `undefined`, `undefined` compares equal to `undefined`, and the
+ * conformance suite reports agreement between two answers that contain nothing.
+ */
+export declare function parseToolResult(name: string, result: unknown, error?: unknown): unknown;
+/**
+ * A minimal MCP client that SPAWNS the shipped entry point.
+ *
+ * Importing the handler module — what every other test does — cannot see the boundary where the
+ * 2026-08-08 defect lived: a server process running a three-day-old build answered `impactedSpecs:
+ * []` for a commit touching 39 specs, while the same handler in a fresh process answered correctly,
+ * and 1,370 tests stayed green throughout. Anything that does not cross a process boundary is blind
+ * to that entire class.
+ *
+ * One server is started per suite and reused, so conformance costs one spawn rather than one per
+ * tool.
+ */
+export declare class StdioClient {
+    private readonly child;
+    private buf;
+    private nextId;
+    private readonly pending;
+    private constructor();
+    /**
+     * @param specsDir  Overrides `HOLMES_SPECS` for the child. Needed because the server binds its
+     *   spec store at start-up from that variable and ignores the `root` argument a tool receives
+     *   (REQ-169) — without this, a write tool driven for conformance lands in the server's own
+     *   project. Measured: it wrote REQ-901.md into this repository.
+     */
+    static start(repoRoot: string, specsDir?: string): Promise<StdioClient>;
+    private send;
+    call(name: string, args: unknown): Promise<unknown>;
+    stop(): void;
+}

package/dist/holmes/mcp/supervisor.d.ts

@@ -0,0 +1,48 @@
+/** Opt-in switch. Absent means the entry point behaves exactly as it did before this existed. */
+export declare const AUTORELOAD_ENV = "HOLMES_MCP_AUTORELOAD";
+export declare function autoreloadEnabled(env: NodeJS.ProcessEnv): boolean;
+/**
+ * Whether the child may be replaced right now.
+ *
+ * Pure, so the three ways this can be wrong are testable without spawning anything.
+ *
+ * An unknown disk build never swaps: not knowing is not divergence, the same posture A-SPEC-160 took
+ * for the digest marker. Reading absence as change would restart continuously on any install whose
+ * build is unstamped.
+ *
+ * An in-flight request never swaps. Each child starts its JSON-RPC id counter at 1, so a mid-request
+ * swap lets the new child's reply match an id the old one issued — an answer delivered to the wrong
+ * question, which is worse than the staleness it was fixing.
+ */
+export declare function shouldSwap(loaded: string, disk: string | undefined, inflight: number): boolean;
+/**
+ * Runs the real server as a child and relays stdio, replacing the child when the build changes.
+ *
+ * A child process rather than `require.cache` surgery: this package depends on nine native addons
+ * (better-sqlite3 plus eight tree-sitter grammars), and re-requiring a `.node` either crashes the
+ * process or leaks the handles it still owns — better-sqlite3 holds open database handles. A fresh
+ * child loads them cleanly, and the client never sees the connection drop.
+ *
+ * This is a CONVENIENCE, not a correctness mechanism. If a swap fails, REQ-156's basis and ART-6
+ * still expose the divergence; making the supervisor responsible for correctness would turn it into
+ * a new single point of failure for the property it was meant to help with.
+ */
+export declare class Supervisor {
+    private readonly repoRoot;
+    private readonly onSwap?;
+    private child?;
+    private inflight;
+    private loaded;
+    /**
+     * The client's opening exchange, replayed into every replacement child. Without it the first call
+     * after a swap hits an uninitialised server and fails — which would break the one promise the
+     * supervisor makes, that the connection does not drop.
+     */
+    private handshake;
+    constructor(repoRoot: string, onSwap?: ((from: string, to: string, replayed: number) => void) | undefined);
+    start(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream): void;
+    private forward;
+    private swap;
+    private spawnChild;
+    stop(): void;
+}

package/dist/holmes/mcp/tool-schemas.d.ts

@@ -0,0 +1,12 @@
+export interface JsonSchema {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+export interface ToolSchema {
+    description: string;
+    inputSchema: JsonSchema;
+}
+export declare const HOOK_ENFORCED_TOOLS: Set<string>;
+export declare const TOOL_SCHEMAS: Record<string, ToolSchema>;

package/dist/holmes/mcp/validate-args.d.ts

@@ -0,0 +1,27 @@
+import { JsonSchema } from './tool-schemas';
+/**
+ * Enforcement for the schemas this server already ADVERTISES.
+ *
+ * The server declared every tool's inputSchema, pinned it 1:1 against the handlers, served it to
+ * clients — and then dispatched `req.params.arguments ?? {}` without ever reading it. Probed: 15 of
+ * 26 handlers threw raw internal errors at `{}`, and a one-key typo in reverse_anchor produced
+ * either a wrong diagnosis ("target A-SPEC undefined is not approved" — blaming approval for an
+ * input problem) or a success-shaped no-op. This module makes the server the first consumer of its
+ * own schemas.
+ *
+ * Deliberately a SUBSET validator: it judges exactly what the repo's `JsonSchema` shape declares —
+ * type / properties / required / items / enum / additionalProperties — and nothing more. A general
+ * JSON Schema engine would silently decide semantics these schemas never state. Pure: no
+ * filesystem, no store; every rule is exercisable from a literal.
+ */
+export type ArgCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function nearKeys(unknown: string, declared: string[]): string[];
+export declare function nearestKey(unknown: string, declared: string[]): string | null;
+/** 시험용 관측점: 요청이 끝난 뒤 메모가 비어 있음을 고정한다(§7f). */
+export declare const NEAR_CACHE_SIZE: () => number;
+export declare function validateArgs(toolName: string, schema: JsonSchema, args: unknown): ArgCheck;

package/dist/holmes/messages/registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Holmes-Kit Centralized Message Registry
+ *
+ * Single Source of Truth for all user/agent-facing refusal, validation, and diagnostic messages.
+ * Unified 3-Part English Format: [Subsystem] Title — Technical Cause — Next Action
+ * Internal Holmes-Kit Spec IDs are strictly masked unless HOLMES_DEBUG=1 is set.
+ */
+export declare const MESSAGES: {
+    SECURITY_ENV_ACCESS: (internalTrace?: string) => string;
+    INTEGRITY_CONFIG_EDIT: (file?: string, internalTrace?: string) => string;
+    GOVERNANCE_LEDGER_DESTRUCTION: (path?: string, internalTrace?: string) => string;
+    SEAL_SELF_APPROVAL_RESTRICTED: (specId: string, internalTrace?: string) => string;
+    SEAL_APPROVED_SPEC_MUTATION: (specId: string, specTitle?: string, internalTrace?: string) => string;
+    GOVERNANCE_UNAPPROVED_TSPEC: (tspecId: string, aspecId: string, aspecTitle?: string, internalTrace?: string) => string;
+    GOVERNANCE_MISSING_TSPEC: (aspecId: string, aspecTitle?: string, internalTrace?: string) => string;
+    VALIDATION_MISSING_REQUIRED: (paramPath: string, description?: string) => string;
+    VALIDATION_TYPO_SUGGESTION: (unknownKey: string, suggestedKey: string) => string;
+    VALIDATION_ENUM_INVALID: (paramName: string, value: string, allowedValues: string[]) => string;
+    VALIDATION_FOREIGN_ROOT: (root: string, boundRoot: string) => string;
+    LEGACY_REVERSE_DRAFT_PARENT: () => string;
+    UNAPPROVED_ASPEC: (aspecId?: string, internalTrace?: string) => string;
+    MISSING_ANCHOR: (targetFile?: string, internalTrace?: string) => string;
+};