project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,21 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { parseSourceItems } from "./long-task-source-item-parser.js";
-export async function compileSourceInventory(repository, sourcePaths) {
-    const items = [];
-    const seen = new Set();
-    for (const [index, relative] of sourcePaths.entries()) {
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), `source[${index}]`);
-        const parsed = parseSourceItems(relative, await readFile(file, "utf8"));
-        if (!parsed.length)
-            throw new Error(`source_file_material_item_required:${relative}`);
-        for (const item of parsed) {
-            if (seen.has(item.key))
-                throw new Error(`source_item_key_duplicate:${item.key}`);
-            seen.add(item.key);
-            items.push(item);
-        }
-    }
-    return items.sort((left, right) => left.key.localeCompare(right.key));
-}

package/dist/lib/long-task-source-item-parser.d.ts

@@ -1,11 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
-import type { DesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export interface ParsedSourceDocument {
-    items: CompiledSourceItemV2[];
-    designResourceHandoff: DesignResourceHandoffInput | null;
-    semanticFactManifest: SemanticFactManifestV1 | null;
-}
-export declare function parseSourceItems(sourcePath: string, content: string): CompiledSourceItemV2[];
-export declare function parseSourceDocument(sourcePath: string, content: string): ParsedSourceDocument;
-export { normalizeSourceItemText } from "./long-task-source-markers.js";

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-projection-resolution.d.ts

@@ -1,5 +0,0 @@
-import type { CompiledSourceItemV2, MaterialSourceFragmentV2 } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { ResolvedSourceProjectionV2 } from "./long-task-source-conservation-types.js";
-export declare function resolveFragmentProjection(fragment: MaterialSourceFragmentV2, manifest: SemanticFactManifestV1): ResolvedSourceProjectionV2;
-export declare function isCanonicalSourceIntegrityStatement(item: CompiledSourceItemV2 | undefined): boolean;

package/dist/lib/long-task-source-projection-resolution.js

@@ -1,57 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function resolveFragmentProjection(fragment, manifest) {
-    const explicit = manifest.inputs.filter((input) => input.kind === "source_fragment" && input.source_ref === fragment.key);
-    if (explicit.length > 1)
-        semanticFactClosureInvalid("source_fragment_disposition_duplicate", fragment.key);
-    if (explicit.length !== 1)
-        semanticFactClosureInvalid("source_fragment_disposition_missing", fragment.key);
-    const input = explicit[0];
-    if (input.sha256 !== fragment.text_sha256)
-        semanticFactClosureInvalid("source_fragment_digest_mismatch", `${input.key}:${fragment.key}`);
-    return {
-        input_key: input.key,
-        disposition: input.disposition,
-        fact_refs: input.fact_refs,
-        basis_refs: input.basis_refs,
-        ...(input.supporting_relation
-            ? { supporting_relation: input.supporting_relation }
-            : {}),
-        explicit: true,
-        authority_derived: false,
-    };
-}
-export function isCanonicalSourceIntegrityStatement(item) {
-    const prefix = "Execution target authority: ";
-    if (item?.kind !== "technical_obligation" ||
-        !item.normalized_text.startsWith(`${prefix}{`) ||
-        !item.normalized_text.endsWith("}."))
-        return false;
-    const encoded = item.normalized_text.slice(prefix.length, -1);
-    try {
-        const value = JSON.parse(encoded);
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            return false;
-        const record = value;
-        if (!sameStrings(Object.keys(record).sort(), [
-            "capabilities",
-            "key",
-            "role",
-            "root_argv",
-            "root_entrypoint",
-            "runtime_family",
-        ]) ||
-            !["key", "role", "root_entrypoint", "runtime_family"].every((key) => typeof record[key] === "string" && record[key].length > 0) ||
-            !["capabilities", "root_argv"].every((key) => Array.isArray(record[key]) &&
-                record[key].every((entry) => typeof entry === "string")))
-            return false;
-        return canonicalValueJson(record) === encoded;
-    }
-    catch {
-        return false;
-    }
-}
-function sameStrings(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}

package/dist/lib/long-task-source-projection-validation.d.ts

@@ -1,17 +0,0 @@
-import type { CompiledSourceItemV2, MaterialSourceFragmentV2, SemanticFactClassV2, SemanticSourceAnchorV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { ResolvedSourceProjectionV2, SourceConservationFactProjectionV2 } from "./long-task-source-conservation-types.js";
-interface SourceProjectionValidationContextV2 {
-    facts: Map<string, SourceConservationFactProjectionV2>;
-    factClasses: Record<string, SemanticFactClassV2>;
-    factDomains: Record<string, SourceAuthorityDomain>;
-    sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>;
-    sourceByKey: ReadonlyMap<string, CompiledSourceItemV2>;
-    manifest: SemanticFactManifestV1;
-    designFactRefsBySource: ReadonlyMap<string, string[]>;
-    factClaimPolarities: ReadonlyMap<string, ReadonlySet<"positive" | "negative">>;
-}
-export declare function validateAnchorProjection(anchor: SemanticSourceAnchorV2, fragmentProjection: ResolvedSourceProjectionV2, context: SourceProjectionValidationContextV2): void;
-export declare function validateProjection(projection: ResolvedSourceProjectionV2, material: MaterialSourceFragmentV2 | SemanticSourceAnchorV2, context: SourceProjectionValidationContextV2): void;
-export declare function validateNoDanglingProjectionInputs(fragments: MaterialSourceFragmentV2[], anchors: SemanticSourceAnchorV2[], manifest: SemanticFactManifestV1): void;
-export {};

package/dist/lib/long-task-source-projection-validation.js

@@ -1,154 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-import { semanticExpectedContains } from "./long-task-source-conservation-facts.js";
-import { semanticModalOccurrences, semanticModalPolarity, } from "./long-task-source-anchors.js";
-import { isCanonicalSourceIntegrityStatement } from "./long-task-source-projection-resolution.js";
-import { validateSameDomainScopeExclusion, validateSameDomainSupersession, } from "./long-task-source-supersession.js";
-export function validateAnchorProjection(anchor, fragmentProjection, context) {
-    const explicit = context.manifest.inputs.filter((input) => input.kind === "semantic_anchor" && input.source_ref === anchor.key);
-    if (explicit.length > 1)
-        semanticFactClosureInvalid("semantic_anchor_disposition_duplicate", anchor.key);
-    const projection = explicit.length
-        ? explicitAnchorProjection(anchor, explicit[0])
-        : fragmentProjection;
-    validateProjection(projection, anchor, context);
-    validateAnchorDisposition(anchor, projection, context);
-}
-function explicitAnchorProjection(anchor, input) {
-    if (input.sha256 !== anchor.value_sha256)
-        semanticFactClosureInvalid("semantic_anchor_digest_mismatch", `${input.key}:${anchor.key}`);
-    return {
-        input_key: input.key,
-        disposition: input.disposition,
-        fact_refs: input.fact_refs,
-        basis_refs: input.basis_refs,
-        ...(input.supporting_relation
-            ? { supporting_relation: input.supporting_relation }
-            : {}),
-        explicit: true,
-        authority_derived: false,
-    };
-}
-function validateAnchorDisposition(anchor, projection, context) {
-    const canonicalSourceIntegrity = isCanonicalSourceIntegrityStatement(context.sourceByKey.get(anchor.source_item_ref));
-    if (projection.disposition === "supporting_basis" &&
-        !canonicalSourceIntegrity)
-        semanticFactClosureInvalid("semantic_anchor_supporting_only_forbidden", anchor.key);
-    if (projection.disposition === "fact_bearing" && anchor.kind === "modal_term")
-        validateModalProjection(anchor, projection, context);
-    else if (projection.disposition === "fact_bearing" &&
-        !projection.fact_refs.some((factRef) => semanticExpectedContains(context.facts.get(factRef), anchor.value)))
-        semanticFactClosureInvalid("semantic_anchor_expected_projection_missing", `${anchor.key}:${anchor.value}`);
-}
-export function validateProjection(projection, material, context) {
-    if (projection.disposition === "decision_required")
-        semanticFactClosureInvalid("source_projection_decision_required", material.key);
-    if (projection.disposition === "fact_bearing")
-        validateFactBearingProjection(projection, material, context);
-    if (projection.disposition === "supporting_basis")
-        validateSupportingProjection(projection, material, context);
-    if (projection.disposition === "superseded")
-        validateSameDomainSupersession(projection, material, context.facts, context.factClasses, context.factDomains, context.sourceDomains, context.sourceByKey, context.manifest);
-    if (projection.disposition === "scope_excluded")
-        validateSameDomainScopeExclusion(projection, material, context.sourceDomains, context.sourceByKey, context.manifest);
-    if ("input_key" in material && projection.disposition === "fact_bearing")
-        validateCompoundModalProjection(projection, material, context);
-}
-function validateFactBearingProjection(projection, material, context) {
-    if (!projection.fact_refs.length)
-        semanticFactClosureInvalid("source_projection_fact_required", material.key);
-    for (const factRef of projection.fact_refs) {
-        const fact = context.facts.get(factRef);
-        if (!fact)
-            semanticFactClosureInvalid("source_projection_fact_unknown", `${material.key}:${factRef}`);
-        if (context.factClasses[factRef] !== "delivery_semantic")
-            semanticFactClosureInvalid("source_integrity_fact_cannot_cover_semantics", `${material.key}:${factRef}`);
-        if (!materialAuthoritySourceRefs(material).some((ref) => fact.source_item_refs.includes(ref)))
-            semanticFactClosureInvalid("source_projection_fact_lineage_mismatch", `${material.key}:${factRef}`);
-        if (context.factDomains[factRef] !== material.authority_domain)
-            semanticFactClosureInvalid("source_projection_fact_domain_mismatch", `${material.key}:${factRef}:${material.authority_domain}:${context.factDomains[factRef]}`);
-        validateFactFragmentProvenance(fact, projection, material, context);
-    }
-}
-function validateSupportingProjection(projection, material, context) {
-    const canonicalSourceIntegrity = isCanonicalSourceIntegrityStatement(context.sourceByKey.get(material.source_item_ref));
-    if (!projection.fact_refs.length)
-        semanticFactClosureInvalid("source_supporting_basis_fact_required", material.key);
-    for (const factRef of projection.fact_refs) {
-        const fact = context.facts.get(factRef);
-        if (!fact)
-            semanticFactClosureInvalid("source_supporting_basis_fact_unknown", `${material.key}:${factRef}`);
-        if (context.factClasses[factRef] !== "delivery_semantic")
-            semanticFactClosureInvalid("source_supporting_basis_delivery_fact_required", `${material.key}:${factRef}`);
-        if (!canonicalSourceIntegrity &&
-            !materialAuthoritySourceRefs(material).some((ref) => fact.source_item_refs.includes(ref)))
-            semanticFactClosureInvalid("source_supporting_basis_fact_lineage_mismatch", `${material.key}:${factRef}`);
-        if (!canonicalSourceIntegrity &&
-            context.factDomains[factRef] !== material.authority_domain)
-            semanticFactClosureInvalid("source_supporting_basis_fact_domain_mismatch", `${material.key}:${factRef}:${material.authority_domain}:${context.factDomains[factRef]}`);
-        validateFactFragmentProvenance(fact, projection, material, context);
-    }
-    if ("input_key" in material && !canonicalSourceIntegrity)
-        validateTypedSupportingRelation(projection, material, context);
-}
-function validateTypedSupportingRelation(projection, material, context) {
-    const relation = projection.supporting_relation;
-    if (!relation)
-        semanticFactClosureInvalid("source_supporting_basis_typed_relation_required", material.key);
-    const materialInput = context.manifest.inputs.find((input) => input.key === material.input_key ||
-        (input.kind === "source_item" && input.source_ref === material.input_key));
-    if (materialInput?.disposition !== "supporting_only")
-        semanticFactClosureInvalid("source_supporting_basis_material_disposition_required", `${material.key}:${materialInput?.key ?? material.input_key}`);
-    if (projection.fact_refs.length !== 1 ||
-        projection.fact_refs[0] !== relation.fact_ref)
-        semanticFactClosureInvalid("source_supporting_basis_relation_fact_mismatch", `${material.key}:${relation.fact_ref}:${projection.fact_refs.join(",")}`);
-    const cell = context.manifest.fact_cells.find((candidate) => candidate.key === relation.fact_cell_ref);
-    if (!cell)
-        semanticFactClosureInvalid("source_supporting_basis_relation_cell_unknown", `${material.key}:${relation.fact_cell_ref}`);
-    if (cell.disposition !== "specified" || cell.fact_ref !== relation.fact_ref)
-        semanticFactClosureInvalid("source_supporting_basis_relation_cell_mismatch", `${material.key}:${relation.fact_cell_ref}:${cell.fact_ref ?? "none"}:${relation.fact_ref}`);
-}
-function validateFactFragmentProvenance(fact, projection, material, context) {
-    const fragmentInputKey = owningFragmentInputKey(projection, material, context.manifest);
-    if (!fact.basis_refs.includes(fragmentInputKey))
-        semanticFactClosureInvalid("source_projection_fact_fragment_provenance_missing", `${material.key}:${fact.key}:${fragmentInputKey}`);
-}
-function owningFragmentInputKey(projection, material, manifest) {
-    if ("input_key" in material)
-        return projection.input_key;
-    const input = manifest.inputs.find((candidate) => candidate.kind === "source_fragment" &&
-        candidate.source_ref === material.fragment_ref);
-    if (!input)
-        semanticFactClosureInvalid("semantic_anchor_fragment_projection_missing", material.key);
-    return input.key;
-}
-function materialAuthoritySourceRefs(material) {
-    return material.authority_source_item_refs;
-}
-function validateModalProjection(anchor, projection, context) {
-    const polarity = semanticModalPolarity(anchor.value);
-    if (!polarity)
-        semanticFactClosureInvalid("semantic_modal_classification_missing", `${anchor.key}:${anchor.value}`);
-    if (!projection.fact_refs.some((factRef) => (context.factClaimPolarities.get(factRef) ?? new Set(["positive"])).has(polarity)))
-        semanticFactClosureInvalid("semantic_modal_claim_polarity_mismatch", `${anchor.key}:${polarity}`);
-}
-function validateCompoundModalProjection(projection, fragment, context) {
-    const occurrences = semanticModalOccurrences(fragment.normalized_text);
-    if (occurrences.length <= 1)
-        return;
-    const facts = projection.fact_refs
-        .map((factRef) => context.facts.get(factRef))
-        .filter((fact) => Boolean(fact));
-    const composite = facts.some((fact) => ["object", "schema", "relation", "decision_table", "formula"].includes(fact.semantic_cell?.value_kind ?? ""));
-    if (!composite && new Set(projection.fact_refs).size < occurrences.length)
-        semanticFactClosureInvalid("source_fragment_modal_fact_split_required", `${fragment.key}:${occurrences.length}:${projection.fact_refs.length}`);
-}
-export function validateNoDanglingProjectionInputs(fragments, anchors, manifest) {
-    const fragmentRefs = new Set(fragments.map((item) => item.key));
-    const anchorRefs = new Set(anchors.map((item) => item.key));
-    for (const input of manifest.inputs) {
-        if (input.kind === "source_fragment" && !fragmentRefs.has(input.source_ref))
-            semanticFactClosureInvalid("source_fragment_projection_dangling", `${input.key}:${input.source_ref}`);
-        if (input.kind === "semantic_anchor" && !anchorRefs.has(input.source_ref))
-            semanticFactClosureInvalid("semantic_anchor_projection_dangling", `${input.key}:${input.source_ref}`);
-    }
-}