project-tiny-context-harness 0.8.17 → 0.11.0

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

@@ -0,0 +1,7 @@
+import type { CompiledSourceItemV2, MaterialTextInputV2 } from "./long-task-source-authority-types.js";
+import type { DesignOwnedSemanticProjectionV1 } from "./long-task-semantic-fact-input-closure.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+import type { SourceSemanticConservationV2 } from "./long-task-source-conservation-types.js";
+export type { SourceSemanticConservationV2 } from "./long-task-source-conservation-types.js";
+export { semanticFactAuthorityDomain, semanticFactClass, } from "./long-task-source-conservation-facts.js";
+export declare function validateSourceSemanticConservation(sourceItems: CompiledSourceItemV2[], manifest: SemanticFactManifestV1, designInput: Set<string> | DesignOwnedSemanticProjectionV1, materialInput?: MaterialTextInputV2[], factClaimPolarities?: ReadonlyMap<string, ReadonlySet<"positive" | "negative">>): SourceSemanticConservationV2;

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

@@ -0,0 +1,110 @@
+import { deriveSemanticSourceAnchors, scanMaterialTextInput, sourceAuthorityDomain, } from "./long-task-source-fragments.js";
+import { addSourceConservationFact, semanticFactAuthorityDomain, semanticFactClass, semanticFactExpectedSearchText, } from "./long-task-source-conservation-facts.js";
+import { resolveFragmentProjection } from "./long-task-source-projection-resolution.js";
+import { validateAnchorProjection, validateNoDanglingProjectionInputs, validateProjection, } from "./long-task-source-projection-validation.js";
+export { semanticFactAuthorityDomain, semanticFactClass, } from "./long-task-source-conservation-facts.js";
+export function validateSourceSemanticConservation(sourceItems, manifest, designInput, materialInput, factClaimPolarities = new Map()) {
+    const designProjection = designInput instanceof Set
+        ? { source_items: designInput, facts: [] }
+        : designInput;
+    const designOwnedSourceItems = designProjection.source_items;
+    const sourceByKey = new Map(sourceItems.map((item) => [item.key, item]));
+    const sourceDomains = sourceAuthorityDomains(sourceItems, designOwnedSourceItems);
+    const facts = sourceConservationFacts(manifest, designProjection, sourceDomains);
+    const factClasses = Object.fromEntries([...facts.values()].map((fact) => [fact.key, fact.semantic_class]));
+    const factDomains = Object.fromEntries([...facts.values()].map((fact) => [fact.key, fact.authority_domain]));
+    const designFactRefsBySource = designFactsBySource(designProjection);
+    const materialInputs = materialInput ??
+        sourceItems.map((item) => ({
+            input_key: item.key,
+            input_kind: "source_item",
+            source_ref: item.source_path,
+            sha256: item.text_sha256,
+            authority_source_item_refs: [item.key],
+            authority_domain: sourceAuthorityDomain(item, designOwnedSourceItems.has(item.key)),
+            normalized_text: item.normalized_text,
+        }));
+    const fragments = materialInputs.flatMap((input) => scanMaterialTextInput(input).fragments);
+    const anchors = [];
+    const validationContext = {
+        facts,
+        factClasses,
+        factDomains,
+        sourceDomains,
+        sourceByKey,
+        manifest,
+        designFactRefsBySource,
+        factClaimPolarities,
+    };
+    for (const material of materialInputs) {
+        const itemFragments = fragments.filter((fragment) => fragment.input_key === material.input_key);
+        for (const fragment of itemFragments) {
+            const projection = resolveFragmentProjection(fragment, manifest);
+            validateProjection(projection, fragment, validationContext);
+            const fragmentAnchors = deriveSemanticSourceAnchors(fragment);
+            anchors.push(...fragmentAnchors);
+            for (const anchor of fragmentAnchors)
+                validateAnchorProjection(anchor, projection, validationContext);
+        }
+    }
+    validateNoDanglingProjectionInputs(fragments, anchors, manifest);
+    return {
+        fragments: fragments.sort((left, right) => left.key.localeCompare(right.key)),
+        anchors: anchors.sort((left, right) => left.key.localeCompare(right.key)),
+        fact_classes: factClasses,
+        fact_domains: factDomains,
+    };
+}
+function sourceAuthorityDomains(sourceItems, designOwned) {
+    return new Map(sourceItems.map((item) => [
+        item.key,
+        sourceAuthorityDomain(item, designOwned.has(item.key)),
+    ]));
+}
+function sourceConservationFacts(manifest, designProjection, sourceDomains) {
+    const facts = new Map();
+    for (const fact of manifest.facts)
+        addSourceConservationFact(facts, {
+            key: fact.key,
+            source_item_refs: fact.source_item_refs,
+            basis_refs: fact.provenance.basis_refs,
+            semantic_class: semanticFactClass(fact),
+            authority_domain: semanticFactAuthorityDomain(fact, sourceDomains),
+            expected_search_text: semanticFactExpectedSearchText(fact),
+            semantic_cell: {
+                outcome_ref: fact.outcome_ref,
+                unit_ref: fact.unit_ref,
+                family_ref: fact.family_ref,
+                condition_ref: fact.condition_ref,
+                property_ref: fact.property_ref,
+                value_kind: fact.value_kind,
+            },
+        });
+    for (const fact of designProjection.facts)
+        addSourceConservationFact(facts, {
+            ...fact,
+            basis_refs: [
+                ...new Set([
+                    ...fact.basis_refs,
+                    ...manifest.inputs
+                        .filter((input) => input.kind === "source_fragment" &&
+                        input.fact_refs.includes(fact.key))
+                        .map((input) => input.key),
+                ]),
+            ],
+            semantic_class: "delivery_semantic",
+            authority_domain: "design",
+            semantic_cell: null,
+        });
+    return facts;
+}
+function designFactsBySource(designProjection) {
+    const result = new Map();
+    for (const fact of designProjection.facts)
+        for (const sourceRef of fact.source_item_refs) {
+            const refs = result.get(sourceRef) ?? [];
+            refs.push(fact.key);
+            result.set(sourceRef, refs);
+        }
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import type { CompiledSourceItemV2, MaterialFragmentScanResultV2, MaterialSourceFragmentV2, MaterialTextInputV2, SourceAuthorityDomain } from "./long-task-source-authority-types.js";
+export { deriveSemanticSourceAnchors, semanticSourceAnchorRef, } from "./long-task-source-anchors.js";
+export declare function sourceAuthorityDomain(item: CompiledSourceItemV2, designOwned: boolean): SourceAuthorityDomain;
+export declare function materialSourceFragmentRef(fragment: Pick<MaterialSourceFragmentV2, "input_key" | "ordinal" | "text_sha256">): string;
+export declare function deriveMaterialSourceFragments(item: CompiledSourceItemV2, designOwned?: boolean): MaterialSourceFragmentV2[];
+export declare function scanMaterialTextInput(input: MaterialTextInputV2): MaterialFragmentScanResultV2;

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

@@ -0,0 +1,219 @@
+import { sha256Hex } from "./strict-codec.js";
+export { deriveSemanticSourceAnchors, semanticSourceAnchorRef, } from "./long-task-source-anchors.js";
+const FENCE_START = /^\s*(`{3,}|~{3,})([^`]*)$/u;
+const TABLE_ROW = /^\s*\|.*\|\s*$/u;
+const TABLE_SEPARATOR = /^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*:?-{3,}:?\s*\|?\s*$/u;
+const MARKDOWN_SEPARATOR = /^\s{0,3}((?:-\s*){3,}|(?:\*\s*){3,}|(?:_\s*){3,})$/u;
+const HEADING = /^\s{0,3}#{1,6}(?:\s+\S|\s*$)/u;
+const BLOCKQUOTE = /^\s{0,3}>/u;
+const TEXTUAL_HTML = /^\s*<(?:[A-Za-z][A-Za-z0-9:-]*(?:\s|>|\/)|!--)/u;
+const GIVEN_WHEN_THEN = /^\s*(?:(?:[-*+] |\d+[.)] ))?(?:(?:Given|When|Then|And|But)\b|(?:假如|当|那么|并且|但是)(?=\s|[:：]))/iu;
+const LIST_ITEM = /^\s*(?:[-*+] |\d+[.)] )\S/u;
+const STRUCTURED_CONFIG = /^\s*(?:(?:["']?[A-Za-z_][\w.-]*["']?)\s*[:=]\s*\S|--[a-z0-9][a-z0-9-]*(?:[ =]\S+)?|[A-Z][A-Z0-9_]*\s*=\s*\S)/u;
+export function sourceAuthorityDomain(item, designOwned) {
+    if (designOwned)
+        return "design";
+    if (item.kind === "acceptance")
+        return "acceptance";
+    if (item.kind === "external_confirmation")
+        return "external";
+    if (["technical_obligation", "forbidden_shortcut", "risk_fact"].includes(item.kind))
+        return "technical";
+    return "product";
+}
+export function materialSourceFragmentRef(fragment) {
+    return `${fragment.input_key}#fragment:${fragment.ordinal}:${fragment.text_sha256.slice(0, 16)}`;
+}
+export function deriveMaterialSourceFragments(item, designOwned = false) {
+    return scanMaterialTextInput({
+        input_key: item.key,
+        input_kind: "source_item",
+        source_ref: item.source_path,
+        sha256: item.text_sha256,
+        authority_source_item_refs: [item.key],
+        authority_domain: sourceAuthorityDomain(item, designOwned),
+        normalized_text: item.normalized_text,
+    }).fragments;
+}
+export function scanMaterialTextInput(input) {
+    const lines = input.normalized_text.replace(/\r\n?/gu, "\n").split("\n");
+    const raw = [];
+    const excludedSeparatorLines = [];
+    let index = 0;
+    while (index < lines.length) {
+        if (!lines[index].trim()) {
+            index += 1;
+            continue;
+        }
+        if (isSeparator(lines[index])) {
+            excludedSeparatorLines.push(index + 1);
+            index += 1;
+            continue;
+        }
+        const fence = FENCE_START.exec(lines[index]);
+        if (fence) {
+            const start = index;
+            const marker = fence[1][0];
+            const width = fence[1].length;
+            index += 1;
+            while (index < lines.length &&
+                !new RegExp(`^\\s*${escapeRegex(marker)}{${width},}\\s*$`, "u").test(lines[index]))
+                index += 1;
+            const end = Math.min(index, lines.length - 1);
+            raw.push({
+                kind: "fenced_code",
+                start,
+                end,
+                text: lines.slice(start, end + 1).join("\n"),
+            });
+            index = index < lines.length ? index + 1 : lines.length;
+            continue;
+        }
+        if (HEADING.test(lines[index])) {
+            raw.push(singleLine("heading", index, lines[index]));
+            index += 1;
+            continue;
+        }
+        if (BLOCKQUOTE.test(lines[index])) {
+            const start = index;
+            while (index < lines.length && BLOCKQUOTE.test(lines[index]))
+                index += 1;
+            raw.push({
+                kind: "blockquote",
+                start,
+                end: index - 1,
+                text: lines.slice(start, index).join("\n"),
+            });
+            continue;
+        }
+        if (TEXTUAL_HTML.test(lines[index])) {
+            const start = index;
+            index += 1;
+            while (index < lines.length &&
+                lines[index].trim() &&
+                !isSpecialLine(lines[index]))
+                index += 1;
+            raw.push({
+                kind: "textual_html",
+                start,
+                end: index - 1,
+                text: lines.slice(start, index).join("\n"),
+            });
+            continue;
+        }
+        if (TABLE_ROW.test(lines[index])) {
+            raw.push(singleLine("table_row", index, lines[index]));
+            index += 1;
+            continue;
+        }
+        if (GIVEN_WHEN_THEN.test(lines[index])) {
+            raw.push(singleLine("given_when_then", index, lines[index]));
+            index += 1;
+            continue;
+        }
+        if (LIST_ITEM.test(lines[index])) {
+            const start = index;
+            index += 1;
+            while (index < lines.length &&
+                lines[index].trim() &&
+                /^\s{2,}\S/u.test(lines[index]) &&
+                !isSpecialLine(lines[index]))
+                index += 1;
+            raw.push({
+                kind: "list_item",
+                start,
+                end: index - 1,
+                text: lines.slice(start, index).join("\n"),
+            });
+            continue;
+        }
+        if (STRUCTURED_CONFIG.test(lines[index])) {
+            raw.push(singleLine("structured_config_line", index, lines[index]));
+            index += 1;
+            continue;
+        }
+        const start = index;
+        index += 1;
+        while (index < lines.length &&
+            lines[index].trim() &&
+            !isSpecialLine(lines[index]))
+            index += 1;
+        raw.push({
+            kind: "paragraph",
+            start,
+            end: index - 1,
+            text: lines.slice(start, index).join("\n"),
+        });
+    }
+    const fragments = raw.map((entry, ordinalIndex) => {
+        const normalizedText = entry.text.trim();
+        const textSha256 = sha256Hex(normalizedText);
+        const base = {
+            input_key: input.input_key,
+            source_item_ref: input.authority_source_item_refs[0],
+            authority_source_item_refs: [...input.authority_source_item_refs],
+            source_path: input.source_ref,
+            authority_domain: input.authority_domain,
+            kind: entry.kind,
+            ordinal: ordinalIndex + 1,
+            start_line: entry.start + 1,
+            end_line: entry.end + 1,
+            normalized_text: normalizedText,
+            text_sha256: textSha256,
+        };
+        return { ...base, key: materialSourceFragmentRef(base) };
+    });
+    const materialNonblankLines = lines.flatMap((line, lineIndex) => line.trim() ? [lineIndex + 1] : []);
+    const coveredLines = fragments.flatMap((fragment) => {
+        const result = [];
+        for (let line = fragment.start_line; line <= fragment.end_line; line += 1)
+            if (lines[line - 1].trim())
+                result.push(line);
+        return result;
+    });
+    assertExactCoverage(input.input_key, materialNonblankLines, coveredLines, excludedSeparatorLines);
+    return {
+        fragments,
+        coverage: {
+            material_nonblank_lines: materialNonblankLines,
+            covered_lines: coveredLines,
+            excluded_separator_lines: excludedSeparatorLines,
+        },
+    };
+}
+function singleLine(kind, index, text) {
+    return { kind, start: index, end: index, text };
+}
+function isSeparator(line) {
+    return TABLE_SEPARATOR.test(line) || MARKDOWN_SEPARATOR.test(line);
+}
+function isSpecialLine(line) {
+    return (FENCE_START.test(line) ||
+        isSeparator(line) ||
+        HEADING.test(line) ||
+        BLOCKQUOTE.test(line) ||
+        TEXTUAL_HTML.test(line) ||
+        TABLE_ROW.test(line) ||
+        GIVEN_WHEN_THEN.test(line) ||
+        LIST_ITEM.test(line) ||
+        STRUCTURED_CONFIG.test(line));
+}
+function assertExactCoverage(inputKey, material, covered, excluded) {
+    const seen = new Set();
+    for (const line of [...covered, ...excluded]) {
+        if (seen.has(line))
+            throw new Error(`material_fragment_coverage_overlap:${inputKey}:${line}`);
+        seen.add(line);
+    }
+    if (material.length !== seen.size ||
+        material.some((line) => !seen.has(line)) ||
+        [...seen].some((line) => !material.includes(line)))
+        throw new Error(`material_fragment_coverage_mismatch:${inputKey}:${material.join(",")}:${[
+            ...seen,
+        ]
+            .sort((left, right) => left - right)
+            .join(",")}`);
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,154 @@
+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}`);
+    }
+}

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

@@ -2,12 +2,7 @@ import { array, fail, key, literal, object, repositorySourceRef, string, strings
 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 row = object(item, itemLabel, ["key", "source_ref", "statement", "disposition"], ["judgment_basis"]);
         const disposition = object(row.disposition, `${itemLabel}.disposition`, ["type"], ["refs", "ref", "reason"]);
         const type = literal(disposition.type, [
             "claim",
@@ -45,9 +40,22 @@ export function parseSourceClaims(value, label) {
                             type,
                             refs: strings(disposition.refs, `${itemLabel}.disposition.refs`),
                         },
+            ...(Object.hasOwn(row, "judgment_basis")
+                ? {
+                    judgment_basis: parseSourceClaimJudgmentBasis(row.judgment_basis, `${itemLabel}.judgment_basis`),
+                }
+                : {}),
         };
     });
 }
+function parseSourceClaimJudgmentBasis(value, label) {
+    const row = object(value, label, ["kind", "claim_ref", "applicability_refs"]);
+    return {
+        kind: literal(row.kind, ["subjective_preference", "expert_assessment", "authorization"], `${label}.kind`),
+        claim_ref: string(row.claim_ref, `${label}.claim_ref`),
+        applicability_refs: strings(row.applicability_refs, `${label}.applicability_refs`),
+    };
+}
 function acceptanceRefs(value, label) {
     const refs = strings(value, label);
     if (refs.length !== 1)

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

@@ -0,0 +1,5 @@
+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";
+export declare function validateSameDomainSupersession(projection: ResolvedSourceProjectionV2, material: MaterialSourceFragmentV2 | SemanticSourceAnchorV2, facts: ReadonlyMap<string, SourceConservationFactProjectionV2>, factClasses: Record<string, SemanticFactClassV2>, factDomains: Record<string, SourceAuthorityDomain>, sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>, sourceByKey: ReadonlyMap<string, CompiledSourceItemV2>, manifest: SemanticFactManifestV1): void;
+export declare function validateSameDomainScopeExclusion(projection: ResolvedSourceProjectionV2, material: MaterialSourceFragmentV2 | SemanticSourceAnchorV2, sourceDomains: ReadonlyMap<string, SourceAuthorityDomain>, sourceByKey: ReadonlyMap<string, CompiledSourceItemV2>, manifest: SemanticFactManifestV1): void;