project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-source-item-parser.js

@@ -1,108 +0,0 @@
-import { parseDesignResourceHandoffInputShape } from "./design-resource-handoff-shape.js";
-import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
-import { parseSemanticFactCompactCarrierShape } from "./semantic-fact-compact-carrier.js";
-import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
-import { assertNoOpenOwnedSection, assertOwnedSourceSectionsClosed, consumeBackgroundBoundary, consumeOwnedText, consumeSourceItemBoundary, } from "./long-task-source-owned-sections.js";
-import { formalBlockBody, forEachSourceLine } from "./source-line-scanner.js";
-import { parseStrictYaml } from "./strict-codec.js";
-const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-(v1|v2)[ \t]*$/u;
-const SEMANTIC_FACT_START = /^\s*```yaml[ \t]+(semantic-fact-manifest-v1|semantic-fact-compact-carrier-v1)[ \t]*$/u;
-const FORMAL_BLOCK_END = /^\s*```[ \t]*$/u;
-export function parseSourceItems(sourcePath, content) {
-    return parseSourceDocument(sourcePath, content).items;
-}
-export function parseSourceDocument(sourcePath, content) {
-    const state = sourceParseState(sourcePath, content);
-    forEachSourceLine(content, (line, startOffset, _endOffset, nextOffset, lineNumber) => consumeSourceLine(state, line, lineNumber, startOffset, nextOffset));
-    assertSourceSectionsClosed(state);
-    return {
-        items: state.items,
-        designResourceHandoff: state.designResourceHandoff,
-        semanticFactManifest: state.semanticFactManifest,
-    };
-}
-function sourceParseState(sourcePath, content) {
-    return {
-        sourcePath,
-        content,
-        items: [],
-        seen: new Set(),
-        seenBackground: new Set(),
-        open: null,
-        background: null,
-        formalBlock: null,
-        designResourceBlocks: 0,
-        semanticFactBlocks: 0,
-        designResourceHandoff: null,
-        semanticFactManifest: null,
-    };
-}
-function consumeSourceLine(state, line, lineNumber, startOffset, nextOffset) {
-    if (consumeOpenFormalBlock(state, line, startOffset))
-        return;
-    if (startFormalBlock(state, line, lineNumber, nextOffset))
-        return;
-    if (consumeSourceItemBoundary(state, line, lineNumber))
-        return;
-    if (consumeBackgroundBoundary(state, line, lineNumber))
-        return;
-    consumeOwnedText(state, line, lineNumber);
-}
-function consumeOpenFormalBlock(state, line, startOffset) {
-    if (!state.formalBlock)
-        return false;
-    if (!FORMAL_BLOCK_END.test(line))
-        return true;
-    try {
-        const value = parseStrictYaml(formalBlockBody(state.content, state.formalBlock.bodyStartOffset, startOffset, state.formalBlock.owner.startsWith("design-resource-handoff-")));
-        if (state.formalBlock.owner === "design-resource-handoff-v1")
-            state.designResourceHandoff = parseDesignResourceHandoffInputShape(value);
-        else if (state.formalBlock.owner === "design-resource-handoff-v2")
-            state.designResourceHandoff =
-                parseDesignResourceSymbolicHandoffShape(value);
-        else if (state.formalBlock.owner === "semantic-fact-compact-carrier-v1")
-            state.semanticFactManifest =
-                parseSemanticFactCompactCarrierShape(value).manifest;
-        else
-            state.semanticFactManifest = parseSemanticFactManifestShape(value);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`source_formal_block_invalid:${state.sourcePath}:${state.formalBlock.line}:${message}`);
-    }
-    state.formalBlock = null;
-    return true;
-}
-function startFormalBlock(state, line, lineNumber, nextOffset) {
-    const designMatch = DESIGN_RESOURCE_START.exec(line);
-    const owner = designMatch
-        ? designMatch[1] === "v2"
-            ? "design-resource-handoff-v2"
-            : "design-resource-handoff-v1"
-        : (SEMANTIC_FACT_START.exec(line)?.[1] ?? null);
-    if (!owner)
-        return false;
-    assertNoOpenOwnedSection(state, lineNumber);
-    if (owner.startsWith("design-resource-handoff-")) {
-        state.designResourceBlocks += 1;
-        if (state.designResourceBlocks > 1)
-            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff`);
-    }
-    else {
-        state.semanticFactBlocks += 1;
-        if (state.semanticFactBlocks > 1)
-            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:semantic-fact-manifest`);
-    }
-    state.formalBlock = {
-        owner,
-        bodyStartOffset: nextOffset,
-        line: lineNumber,
-    };
-    return true;
-}
-function assertSourceSectionsClosed(state) {
-    assertOwnedSourceSectionsClosed(state);
-    if (state.formalBlock)
-        throw new Error(`source_formal_block_unclosed:${state.sourcePath}:${state.formalBlock.owner}:${state.formalBlock.line}`);
-}
-export { normalizeSourceItemText } from "./long-task-source-markers.js";

package/dist/lib/long-task-source-markers.d.ts

@@ -1,12 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
-export declare const SOURCE_ITEM_START: RegExp;
-export declare const SOURCE_ITEM_END: RegExp;
-export declare const SOURCE_BACKGROUND_START: RegExp;
-export declare const SOURCE_BACKGROUND_END: RegExp;
-export declare function parseSourceBackgroundMarker(sourcePath: string, line: number, declaration: string): {
-    key: string;
-    reason: string;
-};
-export declare function parseSourceItemStartMarker(sourcePath: string, line: number, declaration: string): Pick<CompiledSourceItemV2, "key" | "kind" | "aspect" | "risk_semantics">;
-export declare function validateSourceBackgroundLine(sourcePath: string, blockKey: string, reason: string, lineNumber: number, value: string): void;
-export declare function normalizeSourceItemText(value: string): string;

package/dist/lib/long-task-source-markers.js

@@ -1,146 +0,0 @@
-import { RISK_FACT_NAMES } from "./long-task-risk-types.js";
-const KINDS = new Set([
-    "outcome_result",
-    "requirement",
-    "control",
-    "acceptance",
-    "technical_obligation",
-    "non_completing",
-    "non_goal",
-    "forbidden_shortcut",
-    "risk_fact",
-    "external_confirmation",
-    "decision",
-]);
-const RISK_FACTS = new Set(RISK_FACT_NAMES);
-const BACKGROUND_REASONS = new Set(["markdown-structure", "provenance"]);
-export const SOURCE_ITEM_START = /^\s*<!--\s*ty-source-item:start\s+(.+?)\s*-->\s*$/u;
-export const SOURCE_ITEM_END = /^\s*<!--\s*ty-source-item:end\s*-->\s*$/u;
-export const SOURCE_BACKGROUND_START = /^\s*<!--\s*ty-source-background:start\s+(.+?)\s*-->\s*$/u;
-export const SOURCE_BACKGROUND_END = /^\s*<!--\s*ty-source-background:end\s*-->\s*$/u;
-export function parseSourceBackgroundMarker(sourcePath, line, declaration) {
-    const attributes = markerAttributes(sourcePath, line, declaration, "background");
-    for (const name of attributes.keys())
-        if (!["key", "reason"].includes(name))
-            throw new Error(`source_background_marker_attribute_unknown:${sourcePath}:${line}:${name}`);
-    const key = attributes.get("key") ?? "";
-    const reason = attributes.get("reason") ?? "";
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(key) ||
-        !/^[a-z0-9][a-z0-9-]*$/u.test(reason))
-        throw new Error(`source_background_marker_invalid:${sourcePath}:${line}`);
-    if (!BACKGROUND_REASONS.has(reason))
-        throw new Error(`source_background_reason_unknown:${sourcePath}:${line}:${reason}`);
-    return { key, reason };
-}
-export function parseSourceItemStartMarker(sourcePath, line, declaration) {
-    const attributes = markerAttributes(sourcePath, line, declaration, "item");
-    for (const name of attributes.keys())
-        if (!["key", "kind", "aspect", "fact", "outcome"].includes(name))
-            throw new Error(`source_item_marker_attribute_unknown:${sourcePath}:${line}:${name}`);
-    const key = attributes.get("key") ?? "";
-    const kind = (attributes.get("kind") ?? "");
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(key) || !KINDS.has(kind))
-        throw new Error(`source_item_marker_invalid:${sourcePath}:${line}`);
-    return sourceItemMarkerWithRiskSemantics(sourcePath, key, kind, attributes);
-}
-function markerAttributes(sourcePath, line, declaration, marker) {
-    const attributes = new Map();
-    for (const token of declaration.trim().split(/\s+/u)) {
-        const match = /^([a-z_]+)=([^\s=]+)$/u.exec(token);
-        if (!match)
-            throw new Error(`source_${marker}_marker_invalid:${sourcePath}:${line}`);
-        if (attributes.has(match[1]))
-            throw new Error(`source_${marker}_marker_attribute_duplicate:${sourcePath}:${line}:${match[1]}`);
-        attributes.set(match[1], match[2]);
-    }
-    return attributes;
-}
-function sourceItemMarkerWithRiskSemantics(sourcePath, key, kind, attributes) {
-    const fact = attributes.get("fact");
-    const outcome = attributes.get("outcome");
-    const aspect = attributes.get("aspect");
-    if (aspect !== undefined) {
-        if (kind !== "technical_obligation" || aspect !== "architecture")
-            throw new Error(`source_item_aspect_invalid:${sourcePath}:${key}:${kind}:${aspect}`);
-    }
-    if (kind !== "risk_fact") {
-        if (fact !== undefined || outcome !== undefined)
-            throw new Error(`source_item_marker_attributes_forbidden:${sourcePath}:${key}:${kind}`);
-        return {
-            key,
-            kind,
-            ...(aspect === "architecture" ? { aspect } : {}),
-        };
-    }
-    if (aspect !== undefined)
-        throw new Error(`source_item_marker_attributes_forbidden:${sourcePath}:${key}:${kind}`);
-    if (!fact || !outcome)
-        throw new Error(`source_item_risk_semantics_required:${sourcePath}:${key}`);
-    if (!RISK_FACTS.has(fact))
-        throw new Error(`source_item_risk_fact_invalid:${sourcePath}:${key}:${fact}`);
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(outcome))
-        throw new Error(`source_item_risk_outcome_invalid:${sourcePath}:${key}:${outcome}`);
-    return {
-        key,
-        kind,
-        risk_semantics: {
-            fact: fact,
-            affected_outcome: outcome,
-        },
-    };
-}
-export function validateSourceBackgroundLine(sourcePath, blockKey, reason, lineNumber, value) {
-    if (!value.trim())
-        return;
-    const valid = reason === "markdown-structure"
-        ? isMarkdownStructure(value)
-        : reason === "provenance"
-            ? isStructuredProvenance(value)
-            : false;
-    if (!valid)
-        throw new Error(`source_background_content_invalid:${sourcePath}:${blockKey}:${reason}:${lineNumber}`);
-}
-function isMarkdownStructure(value) {
-    return (/^\s*<a\s+(?:id|name)="[A-Za-z0-9_.:-]+"\s*><\/a>\s*$/u.test(value) ||
-        /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/u.test(value));
-}
-function isStructuredProvenance(value) {
-    const declaration = /^\s*<!--\s*ty-source-provenance\s+(.+?)\s*-->\s*$/u.exec(value)?.[1];
-    if (!declaration)
-        return false;
-    const attributes = new Map();
-    for (const token of declaration.split(/\s+/u)) {
-        const match = /^([a-z][a-z0-9_-]*)=([^\s=>]+)$/u.exec(token);
-        if (!match || attributes.has(match[1]))
-            return false;
-        attributes.set(match[1], match[2]);
-    }
-    if ([...attributes.keys()].some((name) => !["input", "mode", "source", "sha256"].includes(name)))
-        return false;
-    const input = attributes.get("input") ?? "";
-    const mode = attributes.get("mode") ?? "";
-    const source = attributes.get("source");
-    const digest = attributes.get("sha256");
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(input))
-        return false;
-    if (!["direct", "derived", "delegated", "evidence-backed"].includes(mode))
-        return false;
-    if (mode !== "direct" && !source)
-        return false;
-    if (source && !/^[a-z0-9][a-z0-9-]*$/u.test(source))
-        return false;
-    if (digest && !/^[a-f0-9]{64}$/u.test(digest))
-        return false;
-    return true;
-}
-export function normalizeSourceItemText(value) {
-    const lines = value
-        .replace(/\r\n?/gu, "\n")
-        .split("\n")
-        .map((line) => line.replace(/[ \t]+$/gu, ""));
-    while (lines.length && !lines[0].trim())
-        lines.shift();
-    while (lines.length && !lines.at(-1).trim())
-        lines.pop();
-    return lines.join("\n");
-}

package/dist/lib/long-task-source-owned-sections.d.ts

@@ -1,29 +0,0 @@
-import type { CompiledSourceItemV2, SourceItemKind } from "./long-task-delivery-types.js";
-interface OpenSourceItem {
-    key: string;
-    kind: SourceItemKind;
-    aspect?: CompiledSourceItemV2["aspect"];
-    risk_semantics?: CompiledSourceItemV2["risk_semantics"];
-    lines: string[];
-    line: number;
-}
-interface OpenSourceBackground {
-    key: string;
-    reason: string;
-    substantiveLines: number;
-    line: number;
-}
-export interface OwnedSourceParseState {
-    sourcePath: string;
-    items: CompiledSourceItemV2[];
-    seen: Set<string>;
-    seenBackground: Set<string>;
-    open: OpenSourceItem | null;
-    background: OpenSourceBackground | null;
-}
-export declare function consumeSourceItemBoundary(state: OwnedSourceParseState, line: string, lineNumber: number): boolean;
-export declare function consumeBackgroundBoundary(state: OwnedSourceParseState, line: string, lineNumber: number): boolean;
-export declare function assertNoOpenOwnedSection(state: OwnedSourceParseState, lineNumber: number): void;
-export declare function consumeOwnedText(state: OwnedSourceParseState, line: string, lineNumber: number): void;
-export declare function assertOwnedSourceSectionsClosed(state: OwnedSourceParseState): void;
-export {};

package/dist/lib/long-task-source-owned-sections.js

@@ -1,90 +0,0 @@
-import { normalizeSourceItemText, parseSourceBackgroundMarker, parseSourceItemStartMarker, SOURCE_BACKGROUND_END, SOURCE_BACKGROUND_START, SOURCE_ITEM_END, SOURCE_ITEM_START, validateSourceBackgroundLine, } from "./long-task-source-markers.js";
-import { sha256Hex } from "./strict-codec.js";
-export function consumeSourceItemBoundary(state, line, lineNumber) {
-    const start = SOURCE_ITEM_START.exec(line);
-    if (start) {
-        assertNoOpenOwnedSection(state, lineNumber);
-        state.open = {
-            ...parseSourceItemStartMarker(state.sourcePath, lineNumber, start[1]),
-            lines: [],
-            line: lineNumber,
-        };
-        return true;
-    }
-    if (!SOURCE_ITEM_END.test(line))
-        return false;
-    if (!state.open)
-        throw new Error(`source_item_end_without_start:${state.sourcePath}:${lineNumber}`);
-    closeSourceItem(state);
-    return true;
-}
-function closeSourceItem(state) {
-    const open = state.open;
-    const normalizedText = normalizeSourceItemText(open.lines.join("\n"));
-    if (!normalizedText)
-        throw new Error(`source_item_empty:${state.sourcePath}:${open.key}`);
-    if (state.seen.has(open.key))
-        throw new Error(`source_item_key_duplicate:${open.key}`);
-    state.seen.add(open.key);
-    state.items.push({
-        key: open.key,
-        kind: open.kind,
-        ...(open.aspect ? { aspect: open.aspect } : {}),
-        source_path: state.sourcePath,
-        normalized_text: normalizedText,
-        text_sha256: sha256Hex(normalizedText),
-        ...(open.risk_semantics ? { risk_semantics: open.risk_semantics } : {}),
-    });
-    state.open = null;
-}
-export function consumeBackgroundBoundary(state, line, lineNumber) {
-    const start = SOURCE_BACKGROUND_START.exec(line);
-    if (start) {
-        assertNoOpenOwnedSection(state, lineNumber);
-        const declaration = parseSourceBackgroundMarker(state.sourcePath, lineNumber, start[1]);
-        if (state.seenBackground.has(declaration.key))
-            throw new Error(`source_background_key_duplicate:${declaration.key}`);
-        state.seenBackground.add(declaration.key);
-        state.background = {
-            ...declaration,
-            substantiveLines: 0,
-            line: lineNumber,
-        };
-        return true;
-    }
-    if (!SOURCE_BACKGROUND_END.test(line))
-        return false;
-    if (!state.background)
-        throw new Error(`source_background_end_without_start:${state.sourcePath}:${lineNumber}`);
-    if (!state.background.substantiveLines)
-        throw new Error(`source_background_empty:${state.sourcePath}:${state.background.key}`);
-    state.background = null;
-    return true;
-}
-export function assertNoOpenOwnedSection(state, lineNumber) {
-    if (!state.open && !state.background)
-        return;
-    throw new Error(`source_section_nested_or_overlapping:${state.sourcePath}:${state.open?.key ?? state.background?.key}:${lineNumber}`);
-}
-export function consumeOwnedText(state, line, lineNumber) {
-    if (line.includes("ty-source-item:start") ||
-        line.includes("ty-source-item:end") ||
-        line.includes("ty-source-background:start") ||
-        line.includes("ty-source-background:end"))
-        throw new Error(`source_item_marker_invalid:${state.sourcePath}:${lineNumber}`);
-    if (state.open)
-        state.open.lines.push(line);
-    else if (state.background) {
-        validateSourceBackgroundLine(state.sourcePath, state.background.key, state.background.reason, lineNumber, line);
-        if (line.trim())
-            state.background.substantiveLines += 1;
-    }
-    else if (line.trim())
-        throw new Error(`source_text_unclassified:${state.sourcePath}:${lineNumber}`);
-}
-export function assertOwnedSourceSectionsClosed(state) {
-    if (state.open)
-        throw new Error(`source_item_unclosed:${state.sourcePath}:${state.open.key}:${state.open.line}`);
-    if (state.background)
-        throw new Error(`source_background_unclosed:${state.sourcePath}:${state.background.key}:${state.background.line}`);
-}

package/dist/lib/long-task-source-shape.d.ts

@@ -1,2 +0,0 @@
-import type { SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function parseSourceClaims(value: unknown, label: string): SourceClaimV2[];

package/dist/lib/long-task-source-shape.js

@@ -1,56 +0,0 @@
-import { array, fail, key, literal, object, repositorySourceRef, string, strings, } from "./long-task-shape-primitives.js";
-export function parseSourceClaims(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "source_ref",
-            "statement",
-            "disposition",
-        ]);
-        const disposition = object(row.disposition, `${itemLabel}.disposition`, ["type"], ["refs", "ref", "reason"]);
-        const type = literal(disposition.type, [
-            "claim",
-            "acceptance",
-            "outcome_result",
-            "global_constraint",
-            "risk_fact",
-            "external_confirmation",
-            "out_of_scope",
-            "decision_required",
-        ], `${itemLabel}.disposition.type`);
-        if (type === "out_of_scope")
-            fail("out_of_scope_requires_non_goal_or_decision", key(row.key, `${itemLabel}.key`));
-        const claimKey = key(row.key, `${itemLabel}.key`);
-        return {
-            key: claimKey,
-            source_ref: repositorySourceRef(row.source_ref, `${itemLabel}.source_ref`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            disposition: type === "decision_required"
-                ? {
-                    type,
-                    reason: string(disposition.reason, `${itemLabel}.disposition.reason`),
-                }
-                : type === "outcome_result"
-                    ? {
-                        type,
-                        ref: string(disposition.ref, `${itemLabel}.disposition.ref`),
-                    }
-                    : type === "acceptance"
-                        ? {
-                            type,
-                            refs: acceptanceRefs(disposition.refs, `${itemLabel}.disposition.refs`),
-                        }
-                        : {
-                            type,
-                            refs: strings(disposition.refs, `${itemLabel}.disposition.refs`),
-                        },
-        };
-    });
-}
-function acceptanceRefs(value, label) {
-    const refs = strings(value, label);
-    if (refs.length !== 1)
-        fail("source_claim_acceptance_ref_count", label);
-    return [refs[0]];
-}

package/dist/lib/long-task-source-target-continuity.d.ts

@@ -1,4 +0,0 @@
-import type { CompiledSourceItemV2, DeliveryContractV2, SourceBackedExecutionTargetV2 } from "./long-task-delivery-types.js";
-type ValidationReporter = (message: string) => void;
-export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): Map<string, SourceBackedExecutionTargetV2>;
-export {};

package/dist/lib/long-task-source-target-continuity.js

@@ -1,141 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { buildCanonicalSourceTargetIndex, executionTargetSourceTargetRef, sourceKindForTarget, } from "./long-task-source-target-index.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function validateSourceTargetContinuity(contract, items, report) {
-    const state = sourceContinuityState(contract, items);
-    for (const claim of contract.source_claims)
-        validateSourceClaimContinuity(claim, state, report);
-    validateAcceptanceBindingContinuity(contract, state, report);
-    validateArchitectureContinuity(state, report);
-    validateRequiredExecutionTargetContinuity(contract, state, report);
-    return state.executionTargetAuthorities;
-}
-function sourceContinuityState(contract, items) {
-    return {
-        itemByKey: new Map(items.map((item) => [item.key, item])),
-        targets: buildCanonicalSourceTargetIndex(contract),
-        owners: new Map(),
-        sourceBackedOutcomeClaims: new Set(),
-        sourceBackedGlobalClaims: new Set(),
-        acceptanceBindings: [],
-        architectureItems: new Set(items
-            .filter((item) => item.aspect === "architecture")
-            .map((item) => item.key)),
-        ownedArchitectureItems: new Set(),
-        executionTargetAuthorities: new Map(),
-    };
-}
-function validateSourceClaimContinuity(claim, state, report) {
-    const item = state.itemByKey.get(claim.key);
-    if (!item || claim.disposition.type === "decision_required")
-        return;
-    const refs = dispositionRefs(claim.disposition);
-    if (refs.length !== 1) {
-        issue(report, `source_claim_target_ref_count:${claim.key}:${refs.length}`);
-        return;
-    }
-    const ref = refs[0];
-    const target = state.targets.get(ref);
-    if (!target ||
-        (target.kind !== "semantic_fact" &&
-            sourceKindForTarget(target) !== item.kind)) {
-        issue(report, `source_target_kind_mismatch:${claim.key}:${item.kind}:${target ? sourceKindForTarget(target) : "unknown"}:${ref}`);
-        return;
-    }
-    if (item.kind === "risk_fact" &&
-        (target.risk_fact !== item.risk_semantics?.fact ||
-            target.affected_outcome !== item.risk_semantics?.affected_outcome)) {
-        issue(report, `source_risk_target_mismatch:${claim.key}:${item.risk_semantics?.fact ?? "missing"}:${item.risk_semantics?.affected_outcome ?? "missing"}:${ref}`);
-        return;
-    }
-    if (target.normalized_text !== undefined &&
-        target.normalized_text !== item.normalized_text) {
-        issue(report, target.execution_target_ref
-            ? `process_root_source_identity_mismatch:${target.execution_target_ref}:${claim.key}`
-            : `source_target_statement_mismatch:${claim.key}:${ref}`);
-        return;
-    }
-    const owner = state.owners.get(ref);
-    if (owner) {
-        issue(report, `source_target_already_owned:${claim.key}:${ref}:${owner}`);
-        return;
-    }
-    state.owners.set(ref, claim.key);
-    if (state.architectureItems.has(item.key) &&
-        target.kind === "technical_obligation")
-        state.ownedArchitectureItems.add(item.key);
-    if (target.outcome_key &&
-        [
-            "requirement",
-            "control",
-            "technical_obligation",
-            "non_completing",
-            "forbidden_shortcut",
-            "semantic_fact",
-        ].includes(target.kind))
-        state.sourceBackedOutcomeClaims.add(ref);
-    if (!target.outcome_key &&
-        ["global_constraint", "non_goal", "forbidden_shortcut"].includes(target.kind))
-        state.sourceBackedGlobalClaims.add(ref);
-    if (target.kind === "acceptance")
-        state.acceptanceBindings.push({ claim, target });
-    if (target.execution_target_ref)
-        state.executionTargetAuthorities.set(target.execution_target_ref, {
-            target_ref: target.execution_target_ref,
-            canonical_target_ref: ref,
-            source_claim_key: claim.key,
-            source_item_key: item.key,
-            source_path: item.source_path,
-            source_text_sha256: item.text_sha256,
-            target_identity: sha256Hex(canonicalValueJson({
-                canonical_target_ref: ref,
-                source_claim_key: claim.key,
-                source_item_key: item.key,
-                source_path: item.source_path,
-                source_text_sha256: item.text_sha256,
-                normalized_text: item.normalized_text,
-            })),
-        });
-}
-function validateRequiredExecutionTargetContinuity(contract, state, report) {
-    for (const targetRef of contract.task.target_profile.required_target_refs) {
-        if (state.executionTargetAuthorities.has(targetRef))
-            continue;
-        const target = contract.task.execution_targets.find((candidate) => candidate.key === targetRef);
-        issue(report, target?.runtime_family === "process"
-            ? `process_root_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`
-            : `execution_target_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`);
-    }
-}
-function validateAcceptanceBindingContinuity(contract, state, report) {
-    for (const { claim, target } of state.acceptanceBindings) {
-        const resolved = resolveAcceptanceAssertion(contract, target.ref);
-        const sourceBacked = resolved?.scope === "outcome" && target.outcome_key
-            ? resolved.assertion.claims.some((localKey) => localKey !== "result" &&
-                state.sourceBackedOutcomeClaims.has(`${target.outcome_key}.${localKey}`))
-            : resolved?.scope === "global"
-                ? resolved.assertion.claims.some((localKey) => state.sourceBackedGlobalClaims.has(localKey))
-                : false;
-        if (!sourceBacked)
-            issue(report, `source_acceptance_without_source_backed_claim:${claim.key}:${target.ref}`);
-    }
-}
-function validateArchitectureContinuity(state, report) {
-    if (!state.architectureItems.size)
-        issue(report, "source_architecture_obligation_required");
-    for (const key of state.architectureItems)
-        if (!state.ownedArchitectureItems.has(key))
-            issue(report, `source_architecture_obligation_unmapped:${key}`);
-}
-function dispositionRefs(disposition) {
-    if (disposition.type === "decision_required")
-        return [];
-    if (disposition.type === "outcome_result")
-        return [disposition.ref];
-    return disposition.refs;
-}
-function issue(report, message) {
-    if (!report)
-        throw new Error(message);
-    report(message);
-}

package/dist/lib/long-task-source-target-index.d.ts

@@ -1,15 +0,0 @@
-import type { DeliveryContractV2, SourceItemKind } from "./long-task-delivery-types.js";
-export interface CanonicalSourceTarget {
-    ref: string;
-    kind: "outcome_result" | "requirement" | "control" | "technical_obligation" | "non_completing" | "global_constraint" | "non_goal" | "forbidden_shortcut" | "acceptance" | "semantic_fact" | "risk_fact" | "external_confirmation";
-    normalized_text?: string;
-    scope?: "global" | "outcome";
-    outcome_key?: string;
-    risk_fact?: keyof DeliveryContractV2["risk"]["facts"];
-    affected_outcome?: string;
-    execution_target_ref?: string;
-}
-export declare function buildCanonicalSourceTargetIndex(contract: DeliveryContractV2): Map<string, CanonicalSourceTarget>;
-export declare function executionTargetSourceTargetRef(targetKey: string): string;
-export declare function executionTargetSourceStatement(targetValue: DeliveryContractV2["task"]["execution_targets"][number]): string;
-export declare function sourceKindForTarget(target: CanonicalSourceTarget): SourceItemKind | null;