project-tiny-context-harness 0.8.8 → 0.8.10

package/dist/lib/design-resource-handoff-validation.js

@@ -2,26 +2,59 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
 import { validateDesignResourceFiles } from "./design-resource-handoff-file-validation.js";
-import { loadAndValidateDesignResourceFactManifests } from "./design-resource-fact-manifest-validation.js";
+import { parseDesignResourceFactManifests, validateDesignResourceFactManifests, } from "./design-resource-fact-manifest-validation.js";
+import { hydrateManifestBackedDesignResourceHandoff } from "./design-resource-handoff-manifest-projection.js";
+import { readDesignResourceSnapshot } from "./design-resource-handoff-snapshot.js";
 import { validateDesignResourceFacts } from "./design-resource-handoff-validation-facts.js";
 import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
 import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
     const parsed = parseDesignResourceHandoffMarkdown(handoffPath, await readFile(handoffFile, "utf8"));
-    validateDesignResourceHandoffSemantics(parsed);
-    const resourceHashes = await validateResourceIntegrity(repository, parsed);
-    await validateDesignResourceFiles(repository, parsed);
-    const manifests = await loadAndValidateDesignResourceFactManifests(repository, parsed);
-    const handoff = parsed.handoff;
+    return preflightParsedDesignResourceHandoff(repository, parsed);
+}
+export async function preflightParsedDesignResourceHandoff(repository, parsed) {
+    const inputHandoff = parsed.handoff;
+    if (isManifestBacked(inputHandoff) && inputHandoff.targets.length !== 1)
+        invalidDesignResourceHandoff("manifest_backed_one_target_required", String(inputHandoff.targets.length));
+    if (!isManifestBacked(inputHandoff))
+        validateDesignResourceHandoffSemantics({
+            ...parsed,
+            handoff: inputHandoff,
+        });
+    const snapshot = await readDesignResourceSnapshot(repository, parsed);
+    const manifests = parseDesignResourceFactManifests(parsed, snapshot.contents);
+    const handoff = isManifestBacked(inputHandoff)
+        ? hydrateManifestBackedDesignResourceHandoff(inputHandoff, manifests)
+        : inputHandoff;
+    const normalized = { ...parsed, handoff };
+    if (isManifestBacked(inputHandoff))
+        validateDesignResourceHandoffSemantics(normalized);
+    validateDesignResourceFiles(normalized, snapshot.contents);
+    validateDesignResourceFactManifests(normalized, snapshot.contents, manifests, !isManifestBacked(inputHandoff));
+    const resources = new Map(handoff.resources.map((resource) => [resource.key, resource]));
     return {
         schema_version: "design-resource-handoff-preflight-v1",
         status: "ready",
-        ...parsed,
-        resource_hashes: resourceHashes,
+        ...normalized,
+        resource_hashes: snapshot.hashes,
+        manifest_identities: handoff.targets.map((target) => {
+            const resourceRef = target.source_profile.fact_manifest_resource_ref;
+            const resource = resources.get(resourceRef);
+            const manifest = manifests.get(target.key);
+            return {
+                resource_ref: resourceRef,
+                path: resource.path,
+                sha256: snapshot.hashes[resourceRef],
+                scope_key: manifest.scope_key,
+                target_key: manifest.target_key,
+                collections: manifest.generation.collections.map((collection) => ({
+                    ...collection,
+                })),
+            };
+        }),
         counts: {
             resources: handoff.resources.length,
             manifests: manifests.size,
@@ -45,6 +78,9 @@ export async function preflightDesignResourceHandoff(repository, handoffPath) {
         },
     };
 }
+function isManifestBacked(handoff) {
+    return "representation" in handoff;
+}
 export function validateDesignResourceHandoffSemantics(parsed) {
     const { handoff } = parsed;
     requireNonemptyDesignResourceValues(handoff.scope.surface_keys, "scope_surface_keys_required");
@@ -104,16 +140,3 @@ export function validateDesignResourceHandoffSemantics(parsed) {
     validateDesignResourceBlockers(handoff, subjects, targets, sourceItems);
     validateDesignResourceReachability(handoff);
 }
-async function validateResourceIntegrity(repository, parsed) {
-    const hashes = {};
-    for (const resource of parsed.handoff.resources) {
-        if (resource.path === parsed.handoff_path)
-            invalidDesignResourceHandoff("resource_must_not_be_handoff", resource.key);
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
-        const digest = sha256Hex(await readFile(file));
-        if (digest !== resource.sha256)
-            invalidDesignResourceHandoff("resource_digest_mismatch", `${resource.key}:${resource.sha256}:${digest}`);
-        hashes[resource.key] = digest;
-    }
-    return hashes;
-}

package/dist/lib/long-task-design-resource-handoff.d.ts

@@ -1,2 +1,17 @@
+import type { DesignResourceHandoffPreflightV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+export interface ContractDesignTarget {
+    outcome_key: string;
+    binding: DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number];
+    target: DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number]["design_targets"][number];
+}
+export interface IndexedHandoffTarget {
+    preflight: DesignResourceHandoffPreflightV1;
+    target: DesignResourceHandoffTargetV1;
+}
+export interface LongTaskDesignHandoffConsumer {
+    consume(preflight: DesignResourceHandoffPreflightV1): void;
+    finish(): void;
+}
 export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string): Promise<void>;
+export declare function createLongTaskDesignHandoffConsumer(contract: DeliveryContractV2): LongTaskDesignHandoffConsumer;

package/dist/lib/long-task-design-resource-handoff.js

@@ -1,63 +1,78 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { containsDesignResourceHandoff } from "./design-resource-handoff-parser.js";
-import { preflightDesignResourceHandoff } from "./design-resource-handoff-validation.js";
+import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
+import { createDesignResourceHandoffSetIntegrity } from "./design-resource-handoff-set-integrity.js";
+import { preflightParsedDesignResourceHandoff } from "./design-resource-handoff-validation.js";
+import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateVerificationMethodBindings, } from "./long-task-design-resource-method-binding.js";
 import { validateLongTaskDesignTargetCapabilities } from "./long-task-design-target-capabilities.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 export async function validateLongTaskDesignResourceHandoffs(contract, repository) {
-    const handoffs = await loadHandoffs(contract, repository);
-    const indexed = indexHandoffTargets(handoffs);
-    const contractTargets = contract.outcomes.flatMap((outcome) => outcome.product.surface_bindings.flatMap((binding) => binding.design_targets.map((target) => ({
-        outcome_key: outcome.key,
-        binding,
-        target,
-    }))));
-    const consumed = new Set();
-    for (const contractTarget of contractTargets) {
-        const indexedTarget = indexed.get(contractTarget.target.key);
-        if (!indexedTarget)
-            invalid("target_handoff_missing", contractTarget.target.key);
-        consumed.add(contractTarget.target.key);
-        validateTargetIdentity(contractTarget, indexedTarget);
-        validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
-        validateCoverageClaims(contract, contractTarget, indexedTarget);
-        validateBlockerBindings(contract, contractTarget, indexedTarget);
-    }
-    for (const key of indexed.keys())
-        if (!consumed.has(key))
-            invalid("handoff_target_unbound", key);
-}
-async function loadHandoffs(contract, repository) {
-    const results = [];
+    const consumer = createLongTaskDesignHandoffConsumer(contract);
     for (const sourcePath of contract.task.source_paths) {
         if (!sourcePath.toLowerCase().endsWith(".md"))
             continue;
         const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourcePath.split("/")), `design_resource_handoff_source:${sourcePath}`);
         const content = await readFile(file, "utf8");
-        if (containsDesignResourceHandoff(content))
-            results.push(await preflightDesignResourceHandoff(repository, sourcePath));
+        if (!containsDesignResourceHandoff(content))
+            continue;
+        consumer.consume(await preflightParsedDesignResourceHandoff(repository, parseDesignResourceHandoffMarkdown(sourcePath, content)));
     }
-    return results;
+    consumer.finish();
 }
-function indexHandoffTargets(handoffs) {
-    const indexed = new Map();
-    for (const preflight of handoffs)
-        for (const target of preflight.handoff.targets) {
-            if (indexed.has(target.key))
-                invalid("handoff_target_duplicate", target.key);
-            indexed.set(target.key, { preflight, target });
-        }
-    return indexed;
-}
-function validateTargetIdentity(contractTarget, indexed) {
-    const { target } = contractTarget;
-    const handoffTarget = indexed.target;
-    if (target.interpretation !== handoffTarget.interpretation)
-        invalid("target_interpretation_mismatch", `${target.key}:${target.interpretation}:${handoffTarget.interpretation}`);
-    assertSameSet(target.condition_keys, handoffTarget.condition_refs, "target_conditions_mismatch", target.key);
-    const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
-        .path);
-    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths], "target_source_paths_mismatch", target.key);
+export function createLongTaskDesignHandoffConsumer(contract) {
+    const contractTargets = contract.outcomes.flatMap((outcome) => outcome.product.surface_bindings.flatMap((binding) => binding.design_targets.map((target) => ({
+        outcome_key: outcome.key,
+        binding,
+        target,
+    }))));
+    const contractTargetsByKey = new Map(contractTargets.map((item) => [item.target.key, item]));
+    const indexedTargetKeys = new Set();
+    const consumed = new Set();
+    const validationErrors = new Map();
+    let duplicate = null;
+    const unbound = [];
+    const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
+    return {
+        consume(preflight) {
+            handoffSetIntegrity.consume(preflight);
+            for (const target of preflight.handoff.targets) {
+                if (indexedTargetKeys.has(target.key)) {
+                    duplicate ??= target.key;
+                    continue;
+                }
+                indexedTargetKeys.add(target.key);
+                const contractTarget = contractTargetsByKey.get(target.key);
+                if (!contractTarget) {
+                    unbound.push(target.key);
+                    continue;
+                }
+                const indexedTarget = { preflight, target };
+                consumed.add(target.key);
+                try {
+                    validateTargetIdentity(contractTarget, indexedTarget);
+                    validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
+                    validateCoverageClaims(contract, contractTarget, indexedTarget);
+                    validateBlockerBindings(contract, contractTarget, indexedTarget);
+                }
+                catch (error) {
+                    validationErrors.set(target.key, error);
+                }
+            }
+        },
+        finish() {
+            if (duplicate)
+                invalid("handoff_target_duplicate", duplicate);
+            handoffSetIntegrity.finish();
+            for (const contractTarget of contractTargets) {
+                if (!consumed.has(contractTarget.target.key))
+                    invalid("target_handoff_missing", contractTarget.target.key);
+                if (validationErrors.has(contractTarget.target.key))
+                    throw validationErrors.get(contractTarget.target.key);
+            }
+            if (unbound.length)
+                invalid("handoff_target_unbound", unbound[0]);
+        },
+    };
 }
 function validateCoverageClaims(contract, contractTarget, indexed) {
     const target = contractTarget.target;
@@ -128,128 +143,3 @@ function validateBlockerBindings(contract, contractTarget, indexed) {
             }
     }
 }
-function designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims = new Map(contract.source_claims.map((item) => [item.key, item]))) {
-    const claim = claims.get(sourceItemRef);
-    if (!claim)
-        invalid("coverage_source_claim_unknown", `${contractTarget.target.key}:${sourceItemRef}`);
-    if (claim.source_ref.split("#")[0] !== indexed.preflight.handoff_path)
-        invalid("coverage_source_claim_file_mismatch", `${contractTarget.target.key}:${sourceItemRef}`);
-    if (claim.disposition.type !== "claim")
-        invalid("coverage_source_claim_disposition_required", `${contractTarget.target.key}:${sourceItemRef}:${claim.disposition.type}`);
-    const prefix = `${contractTarget.outcome_key}.`;
-    return claim.disposition.refs.map((claimRef) => {
-        if (!claimRef.startsWith(prefix))
-            invalid("coverage_claim_outcome_mismatch", `${contractTarget.target.key}:${sourceItemRef}:${claimRef}`);
-        return claimRef.slice(prefix.length);
-    });
-}
-function validateVerificationMethodBindings(target, check, facts, proofs, indexed, claimsBySourceItem) {
-    const expectedMethods = new Set(proofs.map((proof) => proof.method));
-    const bindings = target.verification_method_bindings;
-    assertSameSet(bindings.map((item) => item.method), [...expectedMethods], "verification_methods_mismatch", target.key);
-    const assertionRefs = bindings.map((item) => item.assertion_ref);
-    if (new Set(assertionRefs).size !== assertionRefs.length)
-        invalid("verification_method_assertion_duplicate", target.key);
-    if (assertionRefs.includes(target.conformance_assertion_ref))
-        invalid("verification_method_assertion_must_be_independent", target.key);
-    const boundFactRefs = [];
-    for (const binding of bindings) {
-        const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
-        if (!assertion)
-            invalid("verification_method_assertion_unknown", `${target.key}:${binding.method}:${binding.assertion_ref}`);
-        const sourceItems = new Set(facts
-            .filter((fact) => proofs.some((proof) => proof.fact_ref === fact.key && proof.method === binding.method))
-            .flatMap((fact) => fact.source_item_refs));
-        for (const sourceItemRef of sourceItems)
-            for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
-                if (!assertion.claims.includes(claimRef))
-                    invalid("verification_method_claim_not_asserted", `${target.key}:${binding.method}:${sourceItemRef}:${claimRef}`);
-        for (const capability of requiredCapabilities(binding.method))
-            if (!assertion.evidence_capabilities.includes(capability))
-                invalid("verification_method_capability_required", `${target.key}:${binding.method}:${capability}`);
-        assertSameSet(binding.evidence_artifacts.map((item) => item.condition_key), target.condition_keys, "verification_method_evidence_conditions_mismatch", `${target.key}:${binding.method}`);
-        for (const artifact of binding.evidence_artifacts) {
-            const expectedFactRefs = facts
-                .filter((fact) => proofs.some((proof) => proof.fact_ref === fact.key && proof.method === binding.method) && fact.condition_ref === artifact.condition_key)
-                .map((fact) => fact.key);
-            assertSameSet(artifact.fact_refs, expectedFactRefs, "design_method_fact_refs_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
-            const expectedFactExpectations = proofs
-                .filter((proof) => proof.method === binding.method &&
-                facts.some((fact) => fact.key === proof.fact_ref &&
-                    fact.condition_ref === artifact.condition_key))
-                .map((proof) => designFactExpectation(indexed, proof.fact_ref, proof.key));
-            assertSameSet(artifact.fact_expectations.map((item) => item.fact_ref), expectedFactRefs, "design_method_fact_expectation_refs_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
-            assertCanonicalRows(artifact.fact_expectations, expectedFactExpectations, "design_method_fact_expectations_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
-            boundFactRefs.push(...artifact.fact_refs);
-        }
-    }
-    assertSameSet(boundFactRefs, facts.map((fact) => fact.key), "design_method_fact_refs_mismatch", target.key);
-}
-function designFactExpectation(indexed, factRef, proofRef) {
-    const handoff = indexed.preflight.handoff;
-    const fact = handoff.facts.find((item) => item.key === factRef);
-    const proof = handoff.proof_obligations.find((item) => item.key === proofRef);
-    const oracle = handoff.oracles.find((item) => item.key === proof.oracle_ref);
-    const environment = handoff.environments.find((item) => item.key === proof.environment_ref);
-    return {
-        fact_ref: fact.key,
-        subject_ref: fact.subject_ref,
-        variation_ref: fact.variation_ref,
-        property_ref: fact.property_ref,
-        observation_sensitivity: fact.observation_sensitivity,
-        expected: fact.value,
-        comparison: proof.comparison,
-        oracle: {
-            key: oracle.key,
-            trust: oracle.trust,
-            identity: oracle.identity,
-            version: oracle.version,
-            sha256: oracle.sha256,
-        },
-        environment: {
-            key: environment.key,
-            identity: environment.identity,
-            definition: environment.definition,
-        },
-    };
-}
-function assertCanonicalRows(actual, expected, code, detail) {
-    const left = new Map(actual.map((item) => [item.fact_ref, canonicalJson(item)]));
-    const right = new Map(expected.map((item) => [item.fact_ref, canonicalJson(item)]));
-    assertSameSet([...left.keys()], [...right.keys()], code, detail);
-    for (const [key, value] of right)
-        if (left.get(key) !== value)
-            invalid(code, `${detail}:${key}`);
-}
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
-    if (value && typeof value === "object")
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
-            .join(",")}}`;
-    return JSON.stringify(value);
-}
-function requiredCapabilities(method) {
-    if (method === "interaction_trace")
-        return ["design_method", "interaction_trace", "target_runtime"];
-    if (method === "component_state")
-        return [
-            "design_method",
-            "design_conformance",
-            "interaction_trace",
-            "target_runtime",
-        ];
-    return ["design_method", "design_conformance", "target_runtime"];
-}
-function assertSameSet(actual, expected, code, detail) {
-    const left = [...new Set(actual)].sort();
-    const right = [...new Set(expected)].sort();
-    if (left.length !== right.length ||
-        left.some((item, index) => item !== right[index]))
-        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
-}
-function invalid(code, detail) {
-    throw new Error(`delivery_contract_invalid:design_resource_${code}:${detail}`);
-}

package/dist/lib/long-task-design-resource-method-binding.d.ts

@@ -0,0 +1,8 @@
+import type { DesignResourceHandoffPreflightV1 } from "./design-resource-handoff-types.js";
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { ContractDesignTarget, IndexedHandoffTarget } from "./long-task-design-resource-handoff.js";
+export declare function validateTargetIdentity(contractTarget: ContractDesignTarget, indexed: IndexedHandoffTarget): void;
+export declare function designSourceItemClaims(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, indexed: IndexedHandoffTarget, sourceItemRef: string, claims?: Map<string, import("./long-task-contract-types.js").SourceClaimV2>): string[];
+export declare function validateVerificationMethodBindings(target: ContractDesignTarget["target"], check: DeliveryContractV2["outcomes"][number]["acceptance"]["checks"][number], facts: DesignResourceHandoffPreflightV1["handoff"]["facts"], proofs: DesignResourceHandoffPreflightV1["handoff"]["proof_obligations"], indexed: IndexedHandoffTarget, claimsBySourceItem: Map<string, string[]>): void;
+export declare function assertSameSet(actual: string[], expected: string[], code: string, detail: string): void;
+export declare function invalid(code: string, detail: string): never;

package/dist/lib/long-task-design-resource-method-binding.js

@@ -0,0 +1,135 @@
+export function validateTargetIdentity(contractTarget, indexed) {
+    const { target } = contractTarget;
+    const handoffTarget = indexed.target;
+    if (target.interpretation !== handoffTarget.interpretation)
+        invalid("target_interpretation_mismatch", `${target.key}:${target.interpretation}:${handoffTarget.interpretation}`);
+    assertSameSet(target.condition_keys, handoffTarget.condition_refs, "target_conditions_mismatch", target.key);
+    const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
+        .path);
+    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths], "target_source_paths_mismatch", target.key);
+}
+export function designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims = new Map(contract.source_claims.map((item) => [item.key, item]))) {
+    const claim = claims.get(sourceItemRef);
+    if (!claim)
+        invalid("coverage_source_claim_unknown", `${contractTarget.target.key}:${sourceItemRef}`);
+    if (claim.source_ref.split("#")[0] !== indexed.preflight.handoff_path)
+        invalid("coverage_source_claim_file_mismatch", `${contractTarget.target.key}:${sourceItemRef}`);
+    if (claim.disposition.type !== "claim")
+        invalid("coverage_source_claim_disposition_required", `${contractTarget.target.key}:${sourceItemRef}:${claim.disposition.type}`);
+    const prefix = `${contractTarget.outcome_key}.`;
+    return claim.disposition.refs.map((claimRef) => {
+        if (!claimRef.startsWith(prefix))
+            invalid("coverage_claim_outcome_mismatch", `${contractTarget.target.key}:${sourceItemRef}:${claimRef}`);
+        return claimRef.slice(prefix.length);
+    });
+}
+export function validateVerificationMethodBindings(target, check, facts, proofs, indexed, claimsBySourceItem) {
+    const expectedMethods = new Set(proofs.map((proof) => proof.method));
+    const bindings = target.verification_method_bindings;
+    assertSameSet(bindings.map((item) => item.method), [...expectedMethods], "verification_methods_mismatch", target.key);
+    const assertionRefs = bindings.map((item) => item.assertion_ref);
+    if (new Set(assertionRefs).size !== assertionRefs.length)
+        invalid("verification_method_assertion_duplicate", target.key);
+    if (assertionRefs.includes(target.conformance_assertion_ref))
+        invalid("verification_method_assertion_must_be_independent", target.key);
+    const boundFactRefs = [];
+    for (const binding of bindings) {
+        const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
+        if (!assertion)
+            invalid("verification_method_assertion_unknown", `${target.key}:${binding.method}:${binding.assertion_ref}`);
+        const sourceItems = new Set(facts
+            .filter((fact) => proofs.some((proof) => proof.fact_ref === fact.key && proof.method === binding.method))
+            .flatMap((fact) => fact.source_item_refs));
+        for (const sourceItemRef of sourceItems)
+            for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
+                if (!assertion.claims.includes(claimRef))
+                    invalid("verification_method_claim_not_asserted", `${target.key}:${binding.method}:${sourceItemRef}:${claimRef}`);
+        for (const capability of requiredCapabilities(binding.method))
+            if (!assertion.evidence_capabilities.includes(capability))
+                invalid("verification_method_capability_required", `${target.key}:${binding.method}:${capability}`);
+        assertSameSet(binding.evidence_artifacts.map((item) => item.condition_key), target.condition_keys, "verification_method_evidence_conditions_mismatch", `${target.key}:${binding.method}`);
+        for (const artifact of binding.evidence_artifacts) {
+            const expectedFactRefs = facts
+                .filter((fact) => proofs.some((proof) => proof.fact_ref === fact.key && proof.method === binding.method) && fact.condition_ref === artifact.condition_key)
+                .map((fact) => fact.key);
+            assertSameSet(artifact.fact_refs, expectedFactRefs, "design_method_fact_refs_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
+            const expectedFactExpectations = proofs
+                .filter((proof) => proof.method === binding.method &&
+                facts.some((fact) => fact.key === proof.fact_ref &&
+                    fact.condition_ref === artifact.condition_key))
+                .map((proof) => designFactExpectation(indexed, proof.fact_ref, proof.key));
+            assertSameSet(artifact.fact_expectations.map((item) => item.fact_ref), expectedFactRefs, "design_method_fact_expectation_refs_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
+            assertCanonicalRows(artifact.fact_expectations, expectedFactExpectations, "design_method_fact_expectations_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
+            boundFactRefs.push(...artifact.fact_refs);
+        }
+    }
+    assertSameSet(boundFactRefs, facts.map((fact) => fact.key), "design_method_fact_refs_mismatch", target.key);
+}
+function designFactExpectation(indexed, factRef, proofRef) {
+    const handoff = indexed.preflight.handoff;
+    const fact = handoff.facts.find((item) => item.key === factRef);
+    const proof = handoff.proof_obligations.find((item) => item.key === proofRef);
+    const oracle = handoff.oracles.find((item) => item.key === proof.oracle_ref);
+    const environment = handoff.environments.find((item) => item.key === proof.environment_ref);
+    return {
+        fact_ref: fact.key,
+        subject_ref: fact.subject_ref,
+        variation_ref: fact.variation_ref,
+        property_ref: fact.property_ref,
+        observation_sensitivity: fact.observation_sensitivity,
+        expected: fact.value,
+        comparison: proof.comparison,
+        oracle: {
+            key: oracle.key,
+            trust: oracle.trust,
+            identity: oracle.identity,
+            version: oracle.version,
+            sha256: oracle.sha256,
+        },
+        environment: {
+            key: environment.key,
+            identity: environment.identity,
+            definition: environment.definition,
+        },
+    };
+}
+function assertCanonicalRows(actual, expected, code, detail) {
+    const left = new Map(actual.map((item) => [item.fact_ref, canonicalJson(item)]));
+    const right = new Map(expected.map((item) => [item.fact_ref, canonicalJson(item)]));
+    assertSameSet([...left.keys()], [...right.keys()], code, detail);
+    for (const [key, value] of right)
+        if (left.get(key) !== value)
+            invalid(code, `${detail}:${key}`);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+function requiredCapabilities(method) {
+    if (method === "interaction_trace")
+        return ["design_method", "interaction_trace", "target_runtime"];
+    if (method === "component_state")
+        return [
+            "design_method",
+            "design_conformance",
+            "interaction_trace",
+            "target_runtime",
+        ];
+    return ["design_method", "design_conformance", "target_runtime"];
+}
+export function assertSameSet(actual, expected, code, detail) {
+    const left = [...new Set(actual)].sort();
+    const right = [...new Set(expected)].sort();
+    if (left.length !== right.length ||
+        left.some((item, index) => item !== right[index]))
+        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}
+export function invalid(code, detail) {
+    throw new Error(`delivery_contract_invalid:design_resource_${code}:${detail}`);
+}

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

@@ -1,3 +1,11 @@
 import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
+import type { DesignResourceHandoffInputV1 } from "./design-resource-handoff-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export interface ParsedSourceDocument {
+    items: CompiledSourceItemV2[];
+    designResourceHandoff: DesignResourceHandoffInputV1 | 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";