project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-semantic-fact-input-closure.js

@@ -1,224 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
-import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-import { validateSemanticFactProvenance } from "./long-task-semantic-fact-provenance-closure.js";
-import { deriveMaterialTextInputs } from "./long-task-material-input-closure.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-export function designOwnedSemanticFactProjectionKey(kind, handoffPath, factKey) {
-    return `design.${kind}.${sha256Hex(`${kind}\0${handoffPath}\0${factKey}`)}`;
-}
-export function projectDesignOwnedSemanticFacts(preflights) {
-    const sourceItems = new Set();
-    const facts = new Map();
-    for (const preflight of preflights) {
-        for (const key of preflight.source_item_keys)
-            sourceItems.add(key);
-        if ("preflight_schema_version" in preflight)
-            for (const rule of preflight.manifest.fact_rules)
-                addDesignFactProjection(facts, {
-                    key: designOwnedSemanticFactProjectionKey("fact_rule", preflight.handoff_path, rule.key),
-                    source_item_refs: [...rule.source_item_refs],
-                    basis_refs: [...rule.semantic_obligation_refs],
-                    expected_search_text: [
-                        rule.key,
-                        rule.subject_or_relation_ref,
-                        rule.target_ref,
-                        rule.property_ref,
-                        rule.population_ref ?? "",
-                        rule.quantifier,
-                        rule.value_kind,
-                        rule.provenance_ref,
-                        rule.observation_scope,
-                        rule.expected.locator.resource_ref,
-                        rule.expected.locator.kind,
-                        rule.expected.locator.value,
-                        rule.expected.sha256,
-                        JSON.stringify(rule.region),
-                        ...rule.evidence_refs,
-                        ...rule.census_refs,
-                        ...rule.semantic_obligation_refs,
-                    ].join("\n"),
-                });
-        else
-            for (const fact of preflight.handoff.facts)
-                addDesignFactProjection(facts, {
-                    key: designOwnedSemanticFactProjectionKey("fact", preflight.handoff_path, fact.key),
-                    source_item_refs: [...fact.source_item_refs],
-                    basis_refs: [...fact.evidence_refs],
-                    expected_search_text: [
-                        fact.key,
-                        fact.cell_ref,
-                        fact.subject_ref,
-                        fact.target_ref,
-                        fact.condition_ref,
-                        fact.variation_ref,
-                        fact.property_ref,
-                        fact.dimension,
-                        fact.observation_scope,
-                        fact.value_kind,
-                        fact.value.locator.resource_ref,
-                        fact.value.locator.kind,
-                        fact.value.locator.value,
-                        fact.value.sha256,
-                        fact.lineage.design_system_ref ?? "",
-                        ...fact.lineage.token_chain_refs,
-                        ...fact.lineage.override_chain_refs,
-                        fact.lineage.resolved_value.locator.resource_ref,
-                        fact.lineage.resolved_value.locator.kind,
-                        fact.lineage.resolved_value.locator.value,
-                        fact.lineage.resolved_value.sha256,
-                        ...fact.evidence_refs,
-                    ].join("\n"),
-                });
-    }
-    return {
-        source_items: sourceItems,
-        facts: [...facts.values()].sort((left, right) => left.key.localeCompare(right.key)),
-    };
-}
-function addDesignFactProjection(facts, fact) {
-    if (facts.has(fact.key))
-        semanticFactClosureInvalid("design_fact_projection_duplicate", fact.key);
-    facts.set(fact.key, fact);
-}
-export async function collectDesignOwnedSemanticFactSourceItems(repository, sourcePaths) {
-    const result = new Set();
-    for (const sourcePath of sourcePaths) {
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourcePath.split("/")), `semantic_fact_design_source:${sourcePath}`);
-        const content = await readFile(file, "utf8");
-        if (!containsDesignResourceHandoff(content))
-            continue;
-        const parsed = parseDesignResourceHandoffMarkdown(sourcePath, content);
-        for (const key of parsed.source_item_keys)
-            result.add(key);
-    }
-    return result;
-}
-export async function validateSemanticFactInputInventory(repository, sourceItems, context, manifest, designProjection) {
-    const designOwnedSourceItems = designProjection.source_items;
-    const sourceItemByKey = new Map(sourceItems.map((item) => [item.key, item]));
-    const sourceInputs = manifest.inputs.filter((item) => item.kind === "source_item");
-    assertSameSemanticFactClosureSet(manifest.scope.source_item_refs, sourceItems.map((item) => item.key), "manifest_source_item_universe");
-    assertSameSemanticFactClosureSet(sourceInputs.map((item) => item.source_ref), sourceItems.map((item) => item.key), "input_source_item_universe");
-    validateSourceInputDigests(sourceInputs, sourceItemByKey, designOwnedSourceItems);
-    const contextInputs = manifest.inputs.filter((item) => item.kind === "context");
-    assertSameSemanticFactClosureSet(contextInputs.map((item) => item.source_ref), context.snapshot.files, "input_context_universe");
-    for (const input of manifest.inputs)
-        await validateInput(repository, manifest, input, designOwnedSourceItems, context.physical_files);
-    validateInputFactLineage(manifest, sourceInputs, designProjection.facts);
-    validateSemanticFactProvenance(manifest, sourceItems);
-    return deriveMaterialTextInputs(repository, sourceItems, manifest, designOwnedSourceItems);
-}
-function validateSourceInputDigests(sourceInputs, sourceItemByKey, designOwnedSourceItems) {
-    for (const input of sourceInputs) {
-        const sourceItem = sourceItemByKey.get(input.source_ref);
-        if (input.sha256 !== sourceItem.text_sha256)
-            semanticFactClosureInvalid("input_source_item_digest_mismatch", `${input.key}:${input.source_ref}`);
-        const designOwned = designOwnedSourceItems.has(input.source_ref);
-        if (designOwned
-            ? !["ui_design", "non_ui_material"].includes(input.disposition)
-            : input.disposition !== "non_ui_material")
-            semanticFactClosureInvalid("material_source_item_disposition_mismatch", `${input.key}:${input.source_ref}:${input.disposition}:${designOwned ? "ui_design_or_non_ui_material" : "non_ui_material"}`);
-    }
-}
-async function validateInput(repository, manifest, input, designOwnedSourceItems, contextPhysicalFiles) {
-    const projectionInput = input.kind === "source_fragment" || input.kind === "semantic_anchor";
-    const projectionDispositions = [
-        "fact_bearing",
-        "supporting_basis",
-        "superseded",
-        "decision_required",
-        "scope_excluded",
-    ];
-    const resourceDispositions = [
-        "non_ui_material",
-        "ui_design",
-        "supporting_only",
-        "excluded_by_scope",
-    ];
-    if (projectionInput
-        ? !projectionDispositions.includes(input.disposition)
-        : !resourceDispositions.includes(input.disposition))
-        semanticFactClosureInvalid("input_disposition_kind_mismatch", `${input.key}:${input.kind}:${input.disposition}`);
-    uniqueSemanticFactClosureValues(input.fact_refs, `input_fact_refs:${input.key}`);
-    uniqueSemanticFactClosureValues(input.basis_refs, `input_basis_refs:${input.key}`);
-    const factBearing = ["non_ui_material", "fact_bearing"].includes(input.disposition);
-    const requiresFactRefs = factBearing || input.disposition === "supporting_basis";
-    if (requiresFactRefs ? !input.fact_refs.length : input.fact_refs.length)
-        semanticFactClosureInvalid("input_fact_disposition_mismatch", `${input.key}:${input.disposition}`);
-    if (!factBearing && !input.rationale.trim())
-        semanticFactClosureInvalid("input_disposition_rationale_required", input.key);
-    if (["canonical_spec", "external_constraint", "delegated_instruction"].includes(input.kind) &&
-        input.disposition !== "non_ui_material")
-        semanticFactClosureInvalid("material_input_disposition_mismatch", `${input.key}:${input.kind}:${input.disposition}`);
-    const uiDesignInput = input.kind === "design_resource" ||
-        (input.kind === "source_item" &&
-            designOwnedSourceItems.has(input.source_ref));
-    if (uiDesignInput
-        ? !["ui_design", "non_ui_material"].includes(input.disposition)
-        : input.disposition === "ui_design")
-        semanticFactClosureInvalid("ui_design_input_kind_mismatch", `${input.key}:${input.kind}:${input.disposition}`);
-    if (["excluded_by_scope", "scope_excluded"].includes(input.disposition) &&
-        !manifest.scope.exclusions.some((exclusion) => exclusion.affected_refs.includes(input.key)))
-        semanticFactClosureInvalid("input_scope_exclusion_missing", input.key);
-    if (input.kind === "source_item" || projectionInput)
-        return;
-    const inputPath = input.kind === "context"
-        ? contextPhysicalFiles.get(input.source_ref)
-        : path.resolve(repository, ...input.source_ref.split("/"));
-    if (!inputPath)
-        semanticFactClosureInvalid("input_context_physical_file_missing", `${input.key}:${input.source_ref}`);
-    const file = await assertProtectedRepositoryFile(repository, inputPath, `semantic_fact_input:${input.key}`);
-    const digest = sha256Hex(await readFile(file));
-    if (digest !== input.sha256)
-        semanticFactClosureInvalid("input_resource_digest_mismatch", `${input.key}:${input.source_ref}`);
-}
-function validateInputFactLineage(manifest, sourceInputs, designFacts) {
-    const facts = new Map([
-        ...manifest.facts.map((item) => [
-            item.key,
-            {
-                key: item.key,
-                source_item_refs: item.source_item_refs,
-                basis_refs: item.provenance.basis_refs,
-            },
-        ]),
-        ...designFacts.map((item) => [item.key, item]),
-    ]);
-    const sourceItemRefs = new Set(sourceInputs.map((item) => item.source_ref));
-    for (const input of manifest.inputs)
-        for (const factRef of input.fact_refs)
-            if (!facts.has(factRef))
-                semanticFactClosureInvalid("input_fact_unknown", `${input.key}:${factRef}`);
-            else {
-                const fact = facts.get(factRef);
-                const projectedSourceRef = projectionSourceItemRef(input);
-                if (input.kind === "source_item"
-                    ? !fact.source_item_refs.includes(input.source_ref)
-                    : projectedSourceRef && sourceItemRefs.has(projectedSourceRef)
-                        ? !fact.source_item_refs.includes(projectedSourceRef)
-                        : !fact.basis_refs.includes(input.key))
-                    semanticFactClosureInvalid("input_fact_lineage_mismatch", `${input.key}:${factRef}`);
-            }
-    for (const fact of manifest.facts) {
-        const sourceInputRefs = fact.source_item_refs.map((sourceItemRef) => {
-            const input = sourceInputs.find((item) => item.source_ref === sourceItemRef);
-            if (!input)
-                semanticFactClosureInvalid("fact_source_input_missing", `${fact.key}:${sourceItemRef}`);
-            if (input.disposition !== "non_ui_material" ||
-                !input.fact_refs.includes(fact.key))
-                semanticFactClosureInvalid("fact_source_input_lineage_mismatch", `${fact.key}:${input.key}`);
-            return input.key;
-        });
-        if (!sourceInputRefs.length)
-            semanticFactClosureInvalid("fact_source_input_required", fact.key);
-    }
-}
-function projectionSourceItemRef(input) {
-    if (input.kind !== "source_fragment" && input.kind !== "semantic_anchor")
-        return null;
-    const separator = input.source_ref.indexOf("#fragment:");
-    return separator > 0 ? input.source_ref.slice(0, separator) : null;
-}

package/dist/lib/long-task-semantic-fact-provenance-closure.d.ts

@@ -1,4 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactProvenance(manifest: SemanticFactManifestV1, sourceItems: CompiledSourceItemV2[]): void;
-export declare function validateSemanticFactBasisClosure(manifest: SemanticFactManifestV1, sourceItems: CompiledSourceItemV2[]): void;

package/dist/lib/long-task-semantic-fact-provenance-closure.js

@@ -1,140 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactProvenance(manifest, sourceItems) {
-    const sourceRefs = new Set(sourceItems.map((item) => item.key));
-    const inputByKey = new Map(manifest.inputs.map((item) => [item.key, item]));
-    const materialInputRefs = new Set(manifest.inputs
-        .filter((item) => ["non_ui_material", "fact_bearing"].includes(item.disposition))
-        .map((item) => item.key));
-    const facts = new Map(manifest.facts.map((item) => [item.key, item]));
-    const isMaterialAuthority = (ref) => sourceRefs.has(ref) || materialInputRefs.has(ref);
-    for (const fact of manifest.facts)
-        validateFactAuthority(fact, facts, sourceRefs, inputByKey, isMaterialAuthority);
-    const grounded = new Map();
-    const visit = (factRef, active) => {
-        const cached = grounded.get(factRef);
-        if (cached !== undefined)
-            return cached;
-        if (active.has(factRef))
-            semanticFactClosureInvalid("fact_provenance_cycle", [...active, factRef].join("->"));
-        const fact = facts.get(factRef);
-        const next = new Set(active);
-        next.add(factRef);
-        const result = fact.provenance.basis_refs.some((ref) => isMaterialAuthority(ref) || (facts.has(ref) && visit(ref, next)));
-        grounded.set(factRef, result);
-        return result;
-    };
-    for (const fact of manifest.facts)
-        if (!visit(fact.key, new Set()))
-            semanticFactClosureInvalid("fact_provenance_ungrounded", fact.key);
-}
-function validateFactAuthority(fact, facts, sourceRefs, inputByKey, isMaterialAuthority) {
-    const authorityRef = fact.provenance.authority_ref;
-    if (!fact.provenance.basis_refs.includes(authorityRef))
-        semanticFactClosureInvalid("fact_authority_basis_missing", `${fact.key}:${authorityRef}`);
-    if (authorityRef === fact.key)
-        semanticFactClosureInvalid("fact_authority_self_reference", fact.key);
-    if (!isMaterialAuthority(authorityRef) && !facts.has(authorityRef))
-        semanticFactClosureInvalid("fact_authority_not_groundable", `${fact.key}:${authorityRef}`);
-    if (fact.provenance.kind !== "logically_derived" &&
-        !isMaterialAuthority(authorityRef))
-        semanticFactClosureInvalid("fact_direct_authority_required", `${fact.key}:${fact.provenance.kind}:${authorityRef}`);
-    if (sourceRefs.has(authorityRef) &&
-        !fact.source_item_refs.includes(authorityRef))
-        semanticFactClosureInvalid("fact_authority_source_lineage_mismatch", `${fact.key}:${authorityRef}`);
-    const authorityInput = inputByKey.get(authorityRef);
-    if (authorityInput && !authorityInput.fact_refs.includes(fact.key))
-        semanticFactClosureInvalid("fact_authority_input_lineage_mismatch", `${fact.key}:${authorityRef}`);
-    if (fact.provenance.kind === "explicitly_delegated" &&
-        authorityInput &&
-        authorityInput.kind !== "delegated_instruction" &&
-        authorityInput.kind !== "source_item")
-        semanticFactClosureInvalid("delegated_fact_authority_kind_mismatch", `${fact.key}:${authorityInput.kind}`);
-    if (fact.provenance.kind === "evidence_backed_preservation" &&
-        authorityInput &&
-        !["repository_preservation", "context", "source_item"].includes(authorityInput.kind))
-        semanticFactClosureInvalid("preservation_fact_authority_kind_mismatch", `${fact.key}:${authorityInput.kind}`);
-}
-export function validateSemanticFactBasisClosure(manifest, sourceItems) {
-    const known = semanticFactKnownBasisRefs(manifest, sourceItems);
-    const rows = [];
-    const collect = (label, values) => rows.push(...values.map((item) => ({
-        label: `${label}:${item.key}`,
-        refs: item.basis_refs,
-    })));
-    collect("scope_exclusion", manifest.scope.exclusions);
-    collect("input", manifest.inputs);
-    collect("census", manifest.inspector.census);
-    collect("family", manifest.family_dispositions);
-    collect("subject", manifest.subjects);
-    collect("relation", manifest.relations);
-    collect("population", manifest.populations);
-    collect("axis", manifest.axis_dispositions);
-    collect("axis_value", manifest.axis_dispositions.flatMap((item) => item.values));
-    collect("condition_rule", manifest.condition_rules);
-    collect("condition", manifest.conditions);
-    collect("condition_exclusion", manifest.condition_exclusions);
-    collect("property", manifest.property_dispositions);
-    collect("fact_cell", manifest.fact_cells);
-    addSpecialBasisRows(manifest, rows);
-    for (const row of rows)
-        for (const ref of row.refs)
-            if (!known.has(ref))
-                semanticFactClosureInvalid("basis_ref_unknown", `${row.label}:${ref}`);
-}
-function semanticFactKnownBasisRefs(manifest, sourceItems) {
-    return new Set([
-        manifest.key,
-        ...sourceItems.map((item) => item.key),
-        ...manifest.scope.exclusions.map((item) => item.key),
-        ...manifest.inputs.map((item) => item.key),
-        ...manifest.inspector.census.map((item) => item.key),
-        ...manifest.family_dispositions.map((item) => item.key),
-        ...manifest.subjects.map((item) => item.key),
-        ...manifest.relations.map((item) => item.key),
-        ...manifest.populations.map((item) => item.key),
-        ...manifest.axis_dispositions.map((item) => item.key),
-        ...manifest.axis_dispositions.flatMap((item) => item.values.map((value) => value.key)),
-        ...manifest.condition_rules.map((item) => item.key),
-        ...manifest.conditions.map((item) => item.key),
-        ...manifest.condition_exclusions.map((item) => item.key),
-        ...manifest.property_dispositions.map((item) => item.key),
-        ...manifest.fact_cells.map((item) => item.key),
-        ...manifest.facts.map((item) => item.key),
-        ...manifest.proof_obligations.map((item) => item.key),
-        ...manifest.oracles.map((item) => item.key),
-        ...manifest.environments.map((item) => item.key),
-        ...manifest.blockers.map((item) => item.key),
-    ]);
-}
-function addSpecialBasisRows(manifest, rows) {
-    for (const fact of manifest.facts)
-        rows.push({
-            label: `fact_provenance:${fact.key}`,
-            refs: fact.provenance.basis_refs,
-        });
-    for (const proof of manifest.proof_obligations)
-        rows.push({
-            label: `proof_counterfactual:${proof.key}`,
-            refs: proof.counterfactual.basis_refs,
-        });
-    for (const exclusion of manifest.scope.exclusions)
-        rows.push({
-            label: `scope_exclusion_affected:${exclusion.key}`,
-            refs: exclusion.affected_refs,
-        });
-    for (const population of manifest.populations)
-        rows.push({
-            label: `population_exclusions:${population.key}`,
-            refs: population.exclusion_refs,
-        });
-    for (const blocker of manifest.blockers)
-        rows.push({
-            label: `blocker_affected:${blocker.key}`,
-            refs: blocker.affected_refs,
-        });
-    for (const fact of manifest.facts)
-        rows.push({
-            label: `fact_authority:${fact.key}`,
-            refs: [fact.provenance.authority_ref],
-        });
-}

package/dist/lib/long-task-semantic-fact-shape.d.ts

@@ -1,4 +0,0 @@
-import type { SemanticFactGlobalBindingsV2, SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
-export declare function parseSemanticFactManifestRef(value: unknown, label: string): SemanticFactManifestRefV2;
-export declare function parseSemanticFactOutcomeBindings(value: unknown, label: string): SemanticFactOutcomeBindingsV2;
-export declare function parseSemanticFactGlobalBindings(value: unknown, label: string): SemanticFactGlobalBindingsV2;

package/dist/lib/long-task-semantic-fact-shape.js

@@ -1,134 +0,0 @@
-import { array, EVIDENCE_CAPABILITIES, fail, literal, object, PROOF_SURFACES, repositoryFile, string, } from "./long-task-delivery-shape.js";
-export function parseSemanticFactManifestRef(value, label) {
-    const row = object(value, label, ["key", "source_path", "sha256"]);
-    return {
-        key: semanticRef(row.key, `${label}.key`),
-        source_path: repositoryFile(row.source_path, `${label}.source_path`),
-        sha256: sha256(row.sha256, `${label}.sha256`),
-    };
-}
-export function parseSemanticFactOutcomeBindings(value, label) {
-    const row = object(value, label, ["manifest_ref", "facts", "proofs"]);
-    return {
-        manifest_ref: semanticRef(row.manifest_ref, `${label}.manifest_ref`),
-        facts: array(row.facts, `${label}.facts`).map((item, index) => {
-            const itemLabel = `${label}.facts[${index}]`;
-            const entry = object(item, itemLabel, ["fact_ref", "claim_ref", "applicability_ref"], ["fact_revision_digest", "required_polarity"]);
-            return {
-                fact_ref: semanticRef(entry.fact_ref, `${itemLabel}.fact_ref`),
-                ...(Object.hasOwn(entry, "fact_revision_digest")
-                    ? {
-                        fact_revision_digest: sha256(entry.fact_revision_digest, `${itemLabel}.fact_revision_digest`),
-                    }
-                    : {}),
-                claim_ref: semanticRef(entry.claim_ref, `${itemLabel}.claim_ref`),
-                applicability_ref: semanticRef(entry.applicability_ref, `${itemLabel}.applicability_ref`),
-                ...(Object.hasOwn(entry, "required_polarity")
-                    ? {
-                        required_polarity: literal(entry.required_polarity, ["positive", "negative"], `${itemLabel}.required_polarity`),
-                    }
-                    : {}),
-            };
-        }),
-        proofs: array(row.proofs, `${label}.proofs`).map((item, index) => {
-            const itemLabel = `${label}.proofs[${index}]`;
-            const preliminary = object(item, itemLabel, [
-                "proof_ref",
-                "fact_ref",
-                "method",
-                "proof_surface",
-                "evidence_capabilities",
-                "authority",
-            ], [
-                "obligation_revision_digest",
-                "check_ref",
-                "assertion_ref",
-                "confirmation_ref",
-            ]);
-            const authority = literal(preliminary.authority, ["machine", "external_confirmation"], `${itemLabel}.authority`);
-            if (authority === "machine") {
-                requireOwned(preliminary, itemLabel, ["check_ref", "assertion_ref"]);
-                forbidOwned(preliminary, itemLabel, ["confirmation_ref"]);
-            }
-            else {
-                requireOwned(preliminary, itemLabel, ["confirmation_ref"]);
-                forbidOwned(preliminary, itemLabel, ["check_ref", "assertion_ref"]);
-            }
-            const base = {
-                proof_ref: semanticRef(preliminary.proof_ref, `${itemLabel}.proof_ref`),
-                ...(Object.hasOwn(preliminary, "obligation_revision_digest")
-                    ? {
-                        obligation_revision_digest: sha256(preliminary.obligation_revision_digest, `${itemLabel}.obligation_revision_digest`),
-                    }
-                    : {}),
-                fact_ref: semanticRef(preliminary.fact_ref, `${itemLabel}.fact_ref`),
-                method: semanticRef(preliminary.method, `${itemLabel}.method`),
-                proof_surface: literal(preliminary.proof_surface, PROOF_SURFACES, `${itemLabel}.proof_surface`),
-                evidence_capabilities: array(preliminary.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
-            };
-            return authority === "machine"
-                ? {
-                    ...base,
-                    authority,
-                    check_ref: semanticRef(preliminary.check_ref, `${itemLabel}.check_ref`),
-                    assertion_ref: semanticRef(preliminary.assertion_ref, `${itemLabel}.assertion_ref`),
-                }
-                : {
-                    ...base,
-                    authority,
-                    confirmation_ref: semanticRef(preliminary.confirmation_ref, `${itemLabel}.confirmation_ref`),
-                };
-        }),
-    };
-}
-export function parseSemanticFactGlobalBindings(value, label) {
-    const row = object(value, label, ["manifest_ref", "obligations"]);
-    return {
-        manifest_ref: semanticRef(row.manifest_ref, `${label}.manifest_ref`),
-        obligations: array(row.obligations, `${label}.obligations`).map((item, index) => {
-            const itemLabel = `${label}.obligations[${index}]`;
-            const entry = object(item, itemLabel, [
-                "claim_ref",
-                "applicability_ref",
-                "target_ref",
-                "outcome_ref",
-                "fact_ref",
-                "proof_ref",
-                "method",
-                "required_polarity",
-            ]);
-            return {
-                claim_ref: semanticRef(entry.claim_ref, `${itemLabel}.claim_ref`),
-                applicability_ref: semanticRef(entry.applicability_ref, `${itemLabel}.applicability_ref`),
-                target_ref: semanticRef(entry.target_ref, `${itemLabel}.target_ref`),
-                outcome_ref: semanticRef(entry.outcome_ref, `${itemLabel}.outcome_ref`),
-                fact_ref: semanticRef(entry.fact_ref, `${itemLabel}.fact_ref`),
-                proof_ref: semanticRef(entry.proof_ref, `${itemLabel}.proof_ref`),
-                method: semanticRef(entry.method, `${itemLabel}.method`),
-                required_polarity: literal(entry.required_polarity, ["positive", "negative"], `${itemLabel}.required_polarity`),
-            };
-        }),
-    };
-}
-function semanticRef(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))
-        fail(label, "must be a stable lowercase semantic reference");
-    return result;
-}
-function sha256(value, label) {
-    const result = string(value, label);
-    if (!/^[a-f0-9]{64}$/u.test(result))
-        fail(label, "must be a lowercase SHA-256 digest");
-    return result;
-}
-function requireOwned(row, label, fields) {
-    const missing = fields.filter((field) => !Object.hasOwn(row, field));
-    if (missing.length)
-        fail(label, `missing keys: ${missing.join(",")}`);
-}
-function forbidOwned(row, label, fields) {
-    const present = fields.filter((field) => Object.hasOwn(row, field));
-    if (present.length)
-        fail(label, `forbidden keys: ${present.join(",")}`);
-}

package/dist/lib/long-task-semantic-fact-value-closure.d.ts

@@ -1,3 +0,0 @@
-import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactLocatedValues(repository: string, manifest: SemanticFactManifestV1, sourceItems: CompiledSourceItemV2[]): Promise<void>;

package/dist/lib/long-task-semantic-fact-value-closure.js

@@ -1,110 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveSemanticFactPointer, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { canonicalValueJson, parseStrictYaml, sha256Hex, } from "./strict-codec.js";
-export async function validateSemanticFactLocatedValues(repository, manifest, sourceItems) {
-    const values = collectLocatedValues(manifest);
-    const inputs = new Map(manifest.inputs.map((item) => [item.key, item]));
-    const sourceItemByKey = new Map(sourceItems.map((item) => [item.key, item]));
-    const resourceCache = new Map();
-    for (const entry of values) {
-        const located = entry.value;
-        if (located.representation === "digest_only")
-            continue;
-        const resolved = await resolveLocatedValue(repository, manifest, entry.label, located, inputs, sourceItemByKey, resourceCache);
-        if (resolved.external)
-            continue;
-        if (located.representation === "inline" &&
-            canonicalValueJson(resolved.value) !== canonicalValueJson(located.value))
-            semanticFactClosureInvalid("inline_value_locator_mismatch", entry.label);
-        const digest = sha256Hex(canonicalValueJson(resolved.value));
-        if (digest !== located.sha256)
-            semanticFactClosureInvalid("located_value_digest_mismatch", `${entry.label}:${located.sha256}:${digest}`);
-    }
-}
-function collectLocatedValues(manifest) {
-    return [
-        ...manifest.populations.map((item) => ({
-            label: `population:${item.key}:universe`,
-            value: item.universe,
-        })),
-        ...manifest.facts.map((item) => ({
-            label: `fact:${item.key}:expected`,
-            value: item.expected,
-        })),
-        ...manifest.proof_obligations.flatMap((item) => [
-            {
-                label: `proof:${item.key}:parameters`,
-                value: item.comparison.parameters,
-            },
-            ...(item.comparison.tolerance
-                ? [
-                    {
-                        label: `proof:${item.key}:tolerance`,
-                        value: item.comparison.tolerance,
-                    },
-                ]
-                : []),
-            ...(item.comparison.mask
-                ? [
-                    {
-                        label: `proof:${item.key}:mask`,
-                        value: item.comparison.mask,
-                    },
-                ]
-                : []),
-        ]),
-        ...manifest.environments.map((item) => ({
-            label: `environment:${item.key}`,
-            value: item.definition,
-        })),
-    ];
-}
-async function resolveLocatedValue(repository, manifest, label, located, inputs, sourceItemByKey, resourceCache) {
-    if (located.locator.kind === "manifest_pointer")
-        return {
-            external: false,
-            value: resolveSemanticFactPointer(manifest, located.locator.value, label),
-        };
-    const input = inputs.get(located.locator.material_ref);
-    if (!input)
-        semanticFactClosureInvalid("located_value_input_unknown", `${label}:${located.locator.material_ref}`);
-    if (located.locator.kind === "source_item") {
-        if (input.kind !== "source_item")
-            semanticFactClosureInvalid("located_value_source_item_kind_mismatch", label);
-        const sourceItem = sourceItemByKey.get(input.source_ref);
-        if (!sourceItem)
-            semanticFactClosureInvalid("located_value_source_item_unknown", label);
-        return { external: false, value: sourceItem.normalized_text };
-    }
-    const resource = await loadLocatedResource(repository, input.source_ref, label, located.locator.kind, resourceCache);
-    if (located.locator.kind === "whole_resource")
-        return { external: false, value: resource.raw };
-    if (located.locator.kind === "json_pointer" ||
-        located.locator.kind === "yaml_pointer" ||
-        located.locator.kind === "schema_pointer")
-        return {
-            external: false,
-            value: resolveSemanticFactPointer(resource.parsed, located.locator.value, label),
-        };
-    if (manifest.inspector.trust !== "named_external_tcb" ||
-        !manifest.inspector.capabilities.includes(`resolve.${located.locator.kind}`))
-        semanticFactClosureInvalid("located_value_external_resolver_required", `${label}:${located.locator.kind}`);
-    return { external: true, value: undefined };
-}
-async function loadLocatedResource(repository, sourceRef, label, locatorKind, cache) {
-    const cached = cache.get(sourceRef);
-    if (cached)
-        return cached;
-    const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourceRef.split("/")), `semantic_fact_located_value:${label}`);
-    const raw = await readFile(file, "utf8");
-    let parsed = raw;
-    if (locatorKind === "json_pointer" || locatorKind === "schema_pointer")
-        parsed = JSON.parse(raw);
-    else if (locatorKind === "yaml_pointer")
-        parsed = parseStrictYaml(raw);
-    const resource = { raw, parsed };
-    cache.set(sourceRef, resource);
-    return resource;
-}

package/dist/lib/long-task-semantic-mutation.d.ts

@@ -1,7 +0,0 @@
-import type { CounterfactualMutationV2 } from "./long-task-delivery-types.js";
-type NarrowMutation = Extract<CounterfactualMutationV2, {
-    type: "replace_json_value" | "replace_text";
-}>;
-export declare function applyNarrowSemanticMutation(root: string, mutation: NarrowMutation): Promise<void>;
-export declare function mutateSemanticText(current: string, mutation: NarrowMutation, requireChange?: boolean): string;
-export {};