project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,241 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
-import { createDesignResourceHandoffSetIntegrity } from "./design-resource-handoff-set-integrity.js";
-import { preflightParsedDesignResourceHandoffAny } from "./design-resource-handoff-validation.js";
-import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateSymbolicTargetIdentity, validateSymbolicVerificationMethodBindings, 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";
-import { validateLongTaskDesignFeasibilityBindings } from "./long-task-design-feasibility-binding.js";
-export async function validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems) {
-    const consumer = createLongTaskDesignHandoffConsumer(contract, sourceItems);
-    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))
-            continue;
-        consumer.consume(await preflightParsedDesignResourceHandoffAny(repository, parseDesignResourceHandoffMarkdown(sourcePath, content)));
-    }
-    consumer.finish();
-}
-export function createLongTaskDesignHandoffConsumer(contract, sourceItems = []) {
-    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();
-    const feasibilityBindingRefsBySurface = new Map();
-    let duplicate = null;
-    const unbound = [];
-    const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
-    const allSourceItems = new Set();
-    const resourcePaths = new Map();
-    let crossVersionIssue = null;
-    const recordCrossVersionIssue = (code, detail) => {
-        crossVersionIssue ??= { code, detail };
-    };
-    return {
-        consume(preflight) {
-            for (const sourceItem of preflight.source_item_keys) {
-                if (allSourceItems.has(sourceItem))
-                    recordCrossVersionIssue("handoff_set_source_item_duplicate", sourceItem);
-                else
-                    allSourceItems.add(sourceItem);
-            }
-            for (const resource of preflight.handoff.resources) {
-                const identity = JSON.stringify(resource);
-                const previous = resourcePaths.get(resource.path);
-                if (previous && previous !== identity)
-                    recordCrossVersionIssue("handoff_set_resource_path_conflict", resource.path);
-                else
-                    resourcePaths.set(resource.path, identity);
-            }
-            for (const input of preflight.handoff.technical_feasibility_inputs) {
-                const identity = JSON.stringify(input);
-                const previous = resourcePaths.get(input.path);
-                if (previous && previous !== identity)
-                    recordCrossVersionIssue("handoff_set_feasibility_path_conflict", input.path);
-                else
-                    resourcePaths.set(input.path, identity);
-            }
-            if (!("preflight_schema_version" in 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;
-                }
-                consumed.add(target.key);
-                try {
-                    if ("preflight_schema_version" in preflight) {
-                        const indexedTarget = {
-                            preflight,
-                            target,
-                        };
-                        validateSymbolicTargetIdentity(contractTarget, indexedTarget);
-                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingRefsBySurface, contractTarget, feasibility.consumed_component_binding_refs);
-                        validateSymbolicCoverageClaims(contract, contractTarget, indexedTarget);
-                        validateBlockerBindings(contract, contractTarget, indexedTarget);
-                    }
-                    else {
-                        const indexedTarget = {
-                            preflight,
-                            target: target,
-                        };
-                        validateTargetIdentity(contractTarget, indexedTarget);
-                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingRefsBySurface, contractTarget, feasibility.consumed_component_binding_refs);
-                        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();
-            if (crossVersionIssue)
-                invalid(crossVersionIssue.code, crossVersionIssue.detail);
-            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);
-            }
-            validateSurfaceFeasibilityBindingAttribution(contractTargets, feasibilityBindingRefsBySurface);
-            if (unbound.length)
-                invalid("handoff_target_unbound", unbound[0]);
-        },
-    };
-}
-function recordFeasibilityBindingAttribution(bySurface, contractTarget, bindingRefs) {
-    const key = surfaceBindingIdentity(contractTarget);
-    const consumed = bySurface.get(key) ?? new Set();
-    for (const bindingRef of bindingRefs)
-        consumed.add(bindingRef);
-    bySurface.set(key, consumed);
-}
-function validateSurfaceFeasibilityBindingAttribution(contractTargets, bySurface) {
-    const surfaces = new Map();
-    for (const contractTarget of contractTargets)
-        surfaces.set(surfaceBindingIdentity(contractTarget), contractTarget);
-    for (const [surfaceKey, contractTarget] of surfaces) {
-        const consumed = bySurface.get(surfaceKey) ?? new Set();
-        for (const bindingRef of contractTarget.binding.component_binding_refs)
-            if (!consumed.has(bindingRef))
-                invalid("feasibility_component_binding_unattributed", `${contractTarget.binding.key}:${bindingRef}`);
-    }
-}
-function surfaceBindingIdentity(contractTarget) {
-    return `${contractTarget.outcome_key}\0${contractTarget.binding.key}`;
-}
-function validateSymbolicCoverageClaims(contract, contractTarget, indexed) {
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const rows = indexed.preflight.handoff.coverage.filter((row) => row.target_ref === contractTarget.target.key);
-    if (!rows.length)
-        invalid("v2_target_covered_claims_required", contractTarget.target.key);
-    const sourceItemRefs = [
-        ...new Set([
-            ...rows.flatMap((row) => row.source_item_refs),
-            ...indexed.preflight.manifest.fact_rules.flatMap((rule) => rule.source_item_refs),
-            ...indexed.preflight.manifest.disposition_regions.flatMap((region) => region.source_item_refs),
-        ]),
-    ];
-    const claimsBySourceItem = new Map();
-    for (const sourceItemRef of sourceItemRefs)
-        claimsBySourceItem.set(sourceItemRef, designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims));
-    validateSymbolicVerificationMethodBindings(contract, contractTarget, indexed, claimsBySourceItem);
-}
-function validateCoverageClaims(contract, contractTarget, indexed) {
-    const target = contractTarget.target;
-    const check = contract.outcomes
-        .find((item) => item.key === contractTarget.outcome_key)
-        .acceptance.checks.find((item) => item.key === target.conformance_check_ref);
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const rows = indexed.preflight.handoff.coverage.filter((row) => row.disposition === "covered" && row.target_refs.includes(target.key));
-    if (!rows.length)
-        invalid("target_covered_claims_required", target.key);
-    const facts = indexed.preflight.handoff.facts.filter((fact) => fact.target_ref === target.key);
-    const factRefs = new Set(facts.map((fact) => fact.key));
-    const proofs = indexed.preflight.handoff.proof_obligations.filter((proof) => factRefs.has(proof.fact_ref));
-    if (!facts.length)
-        invalid("target_facts_required", target.key);
-    const claimsBySourceItem = new Map();
-    for (const row of rows)
-        for (const sourceItemRef of row.source_item_refs) {
-            const localClaims = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
-            claimsBySourceItem.set(sourceItemRef, localClaims);
-        }
-    validateVerificationMethodBindings(target, check, facts, proofs, indexed, claimsBySourceItem);
-}
-function validateBlockerBindings(contract, contractTarget, indexed) {
-    const bound = new Map(contractTarget.binding.acceptance_blockers.map((item) => [item.key, item]));
-    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
-    const confirmations = new Map(contract.global.acceptance.external_confirmations.map((item) => [
-        item.key,
-        item,
-    ]));
-    const availableMethods = new Set([
-        ...contractTarget.target.verification_method_bindings,
-        ...(contractTarget.target.symbolic_method_bindings ?? []),
-    ].map((item) => item.method));
-    const blockers = "preflight_schema_version" in indexed.preflight
-        ? indexed.preflight.manifest.acceptance_blockers
-        : indexed.preflight.handoff.acceptance_blockers;
-    for (const blocker of blockers) {
-        if (!blocker.target_refs.includes(contractTarget.target.key))
-            continue;
-        const contractBlocker = bound.get(blocker.key);
-        if (!contractBlocker)
-            invalid("acceptance_blocker_unbound", `${contractTarget.target.key}:${blocker.key}`);
-        assertSameSet(contractBlocker.source_item_refs, blocker.source_item_refs, "acceptance_blocker_source_items_mismatch", blocker.key);
-        assertSameSet(contractBlocker.verification_methods, blocker.verification_methods, "acceptance_blocker_methods_mismatch", blocker.key);
-        assertSameSet(contractBlocker.required_capabilities, blocker.required_capabilities, "acceptance_blocker_capabilities_mismatch", blocker.key);
-        for (const method of blocker.verification_methods)
-            if (!availableMethods.has(method))
-                invalid("acceptance_blocker_method_unbound", `${blocker.key}:${method}`);
-        const fullClaimRefs = blocker.source_item_refs.flatMap((sourceItemRef) => {
-            const local = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
-            return local.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`);
-        });
-        if (contractBlocker.status === "machine_claim") {
-            const executionTarget = contract.task.execution_targets.find((item) => item.key === contractTarget.binding.target_ref);
-            if (!executionTarget)
-                invalid("execution_target_unknown", `${contractTarget.target.key}:${contractTarget.binding.target_ref}`);
-            for (const capability of blocker.required_capabilities)
-                if (!executionTarget.capabilities.includes(capability))
-                    invalid("acceptance_blocker_target_capability_missing", `${blocker.key}:${executionTarget.key}:${capability}`);
-            const expectedLocal = fullClaimRefs.map((claimRef) => claimRef.slice(contractTarget.outcome_key.length + 1));
-            for (const claimRef of expectedLocal)
-                if (!contractBlocker.refs.includes(claimRef))
-                    invalid("acceptance_blocker_machine_claim_lineage_missing", `${blocker.key}:${claimRef}`);
-        }
-        else
-            for (const confirmationRef of contractBlocker.refs) {
-                const confirmation = confirmations.get(confirmationRef);
-                if (!confirmation)
-                    invalid("acceptance_blocker_confirmation_unknown", `${blocker.key}:${confirmationRef}`);
-                for (const claimRef of fullClaimRefs)
-                    if (!confirmation.impact_claims.includes(claimRef))
-                        invalid("acceptance_blocker_confirmation_lineage_missing", `${blocker.key}:${confirmationRef}:${claimRef}`);
-            }
-    }
-}

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

@@ -1,15 +0,0 @@
-import type { DesignResourceHandoffPreflightV1 } from "./design-resource-handoff-types.js";
-import type { DesignResourceHandoffPreflightV2, DesignResourceSymbolicHandoffTargetV2 } from "./design-resource-symbolic-fact-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 interface IndexedSymbolicHandoffTarget {
-    preflight: DesignResourceHandoffPreflightV2;
-    target: DesignResourceSymbolicHandoffTargetV2;
-}
-export declare function validateSymbolicTargetIdentity(contractTarget: ContractDesignTarget, indexed: IndexedSymbolicHandoffTarget): void;
-export declare function validateSymbolicVerificationMethodBindings(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, indexed: IndexedSymbolicHandoffTarget, claimsBySourceItem: Map<string, string[]>): void;
-export declare function designSourceItemClaims(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, indexed: IndexedHandoffTarget | IndexedSymbolicHandoffTarget, 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

@@ -1,297 +0,0 @@
-import { designResourceSymbolicNoninterferenceProofDigest } from "./design-resource-symbolic-validation-support.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-export function validateTargetIdentity(contractTarget, indexed) {
-    const { target } = contractTarget;
-    if (target.fact_model !== undefined)
-        invalid("v1_target_fact_model_must_be_absent", target.key);
-    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);
-    const feasibilityPaths = indexed.preflight.handoff.technical_feasibility_inputs
-        .filter((item) => item.target_ref === handoffTarget.key)
-        .map((item) => item.path);
-    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths, ...feasibilityPaths], "target_source_paths_mismatch", target.key);
-}
-export function validateSymbolicTargetIdentity(contractTarget, indexed) {
-    const { target } = contractTarget;
-    const handoffTarget = indexed.target;
-    if (target.fact_model !== "symbolic_rules_v2")
-        invalid("v2_target_fact_model_required", target.key);
-    if (target.interpretation !== handoffTarget.interpretation)
-        invalid("target_interpretation_mismatch", `${target.key}:${target.interpretation}:${handoffTarget.interpretation}`);
-    if (target.condition_keys.length)
-        invalid("v2_ground_condition_keys_forbidden", target.key);
-    if (target.verification_method_bindings.length)
-        invalid("v2_ground_method_bindings_forbidden", target.key);
-    const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
-        .path);
-    const feasibilityPaths = indexed.preflight.handoff.technical_feasibility_inputs
-        .filter((item) => item.target_ref === handoffTarget.key)
-        .map((item) => item.path);
-    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths, ...feasibilityPaths], "target_source_paths_mismatch", target.key);
-}
-export function validateSymbolicVerificationMethodBindings(contract, contractTarget, indexed, claimsBySourceItem) {
-    const target = contractTarget.target;
-    const preflight = indexed.preflight;
-    const check = contract.outcomes
-        .find((item) => item.key === contractTarget.outcome_key)
-        .acceptance.checks.find((item) => item.key === target.conformance_check_ref);
-    const bindings = target.symbolic_method_bindings ?? [];
-    const expectedMethods = [
-        ...new Set(preflight.manifest.semantic_proof_obligations.map((item) => item.method)),
-    ];
-    assertSameSet(bindings.map((item) => item.method), expectedMethods, "v2_verification_methods_mismatch", target.key);
-    const assertionRefs = bindings.map((item) => item.assertion_ref);
-    if (new Set(assertionRefs).size !== assertionRefs.length)
-        invalid("v2_verification_method_assertion_duplicate", target.key);
-    if (assertionRefs.includes(target.conformance_assertion_ref))
-        invalid("v2_verification_method_assertion_must_be_independent", target.key);
-    const boundObligationRefs = [];
-    const artifactPaths = new Set();
-    for (const binding of bindings) {
-        const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
-        if (!assertion)
-            invalid("v2_verification_method_assertion_unknown", `${target.key}:${binding.method}:${binding.assertion_ref}`);
-        const assertedClaims = claimsAssertedByRootOrMethod(target, check, assertion.claims);
-        for (const capability of requiredCapabilities(binding.method))
-            if (!assertion.evidence_capabilities.includes(capability))
-                invalid("v2_verification_method_capability_required", `${target.key}:${binding.method}:${capability}`);
-        const expected = preflight.manifest.semantic_proof_obligations
-            .filter((obligation) => obligation.method === binding.method)
-            .map((obligation) => symbolicRuleExpectation(preflight, obligation.key));
-        assertCanonicalRowsByKey(binding.rule_expectations, expected, "obligation_ref", "v2_rule_expectations_mismatch", `${target.key}:${binding.method}`);
-        for (const expectation of expected) {
-            const rule = preflight.manifest.fact_rules.find((item) => item.key === expectation.fact_rule_ref);
-            for (const sourceItemRef of rule.source_item_refs)
-                for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
-                    if (!assertedClaims.has(claimRef))
-                        invalid("v2_verification_method_claim_not_asserted", `${target.key}:${binding.method}:${sourceItemRef}:${claimRef}`);
-            boundObligationRefs.push(expectation.obligation_ref);
-        }
-        for (const artifactPath of [
-            binding.artifact_path,
-            binding.observation_path,
-        ]) {
-            if (artifactPaths.has(artifactPath))
-                invalid("v2_evidence_artifact_reused", `${target.key}:${artifactPath}`);
-            artifactPaths.add(artifactPath);
-            if (!check.artifact_globs.some((pattern) => matchesRepoPattern(artifactPath, pattern)))
-                invalid("v2_evidence_artifact_glob_missing", artifactPath);
-        }
-    }
-    assertSameSet(boundObligationRefs, preflight.manifest.semantic_proof_obligations.map((item) => item.key), "v2_semantic_obligation_binding_mismatch", target.key);
-    validateSymbolicCertificateBinding(target, preflight, check, assertionRefs, artifactPaths);
-}
-function validateSymbolicCertificateBinding(target, preflight, check, assertionRefs, artifactPaths) {
-    const certificateBinding = target.symbolic_certificate_binding;
-    if (!certificateBinding)
-        invalid("v2_certificate_binding_required", target.key);
-    const certificateAssertion = check.positive_assertions.find((item) => item.key === certificateBinding.assertion_ref);
-    if (!certificateAssertion)
-        invalid("v2_certificate_assertion_unknown", `${target.key}:${certificateBinding.assertion_ref}`);
-    if (certificateBinding.assertion_ref === target.conformance_assertion_ref ||
-        assertionRefs.includes(certificateBinding.assertion_ref))
-        invalid("v2_certificate_assertion_must_be_independent", target.key);
-    if (!certificateAssertion.evidence_capabilities.includes("design_symbolic_certificate"))
-        invalid("v2_certificate_capability_required", `${target.key}:${certificateBinding.assertion_ref}`);
-    const expectedCertificates = preflight.manifest.noninterference_certificates.map((certificate) => {
-        const sourceProofDigest = designResourceSymbolicNoninterferenceProofDigest(certificate.source_noninterference_proof);
-        const productionProofDigest = designResourceSymbolicNoninterferenceProofDigest(certificate.production_noninterference_proof);
-        return {
-            certificate_ref: certificate.key,
-            fact_rule_refs: [...certificate.fact_rule_refs],
-            omitted_axis_refs: [...certificate.omitted_axis_refs],
-            dependency_edge_refs: [...certificate.dependency_edge_refs],
-            canonical_rule_dag_sha256: certificate.canonical_rule_dag_sha256,
-            ...(sourceProofDigest
-                ? { source_noninterference_proof_sha256: sourceProofDigest }
-                : {}),
-            ...(productionProofDigest
-                ? { production_noninterference_proof_sha256: productionProofDigest }
-                : {}),
-        };
-    });
-    assertCanonicalRowsByKey(certificateBinding.expectations, expectedCertificates, "certificate_ref", "v2_certificate_expectations_mismatch", target.key);
-    if (canonicalJson(certificateBinding.metrics) !==
-        canonicalJson(preflight.metrics))
-        invalid("v2_certificate_metrics_mismatch", target.key);
-    if (!check.artifact_globs.some((pattern) => matchesRepoPattern(certificateBinding.artifact_path, pattern)))
-        invalid("v2_certificate_artifact_glob_missing", certificateBinding.artifact_path);
-    if (artifactPaths.has(certificateBinding.artifact_path))
-        invalid("v2_certificate_artifact_reused", `${target.key}:${certificateBinding.artifact_path}`);
-}
-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 assertedClaims = claimsAssertedByRootOrMethod(target, check, assertion.claims);
-        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 (!assertedClaims.has(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 claimsAssertedByRootOrMethod(target, check, methodClaims) {
-    const rootAssertion = check.positive_assertions.find((item) => item.key === target.conformance_assertion_ref);
-    return new Set([...(rootAssertion?.claims ?? []), ...methodClaims]);
-}
-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 symbolicRuleExpectation(preflight, obligationRef) {
-    const obligation = preflight.manifest.semantic_proof_obligations.find((item) => item.key === obligationRef);
-    const rule = preflight.manifest.fact_rules.find((item) => item.key === obligation.fact_rule_ref);
-    const oracle = preflight.manifest.oracles.find((item) => item.key === obligation.oracle_ref);
-    const environment = preflight.manifest.environments.find((item) => item.key === obligation.environment_ref);
-    return {
-        obligation_ref: obligation.key,
-        fact_rule_ref: rule.key,
-        region_sha256: obligation.region_sha256,
-        subject_or_relation_ref: rule.subject_or_relation_ref,
-        property_ref: rule.property_ref,
-        population_ref: rule.population_ref,
-        quantifier: structuredClone(rule.quantifier),
-        observation_sensitivity: rule.observation_sensitivity,
-        expected: structuredClone(rule.expected),
-        proof_surface: obligation.proof_surface,
-        observation_boundary: obligation.observation_boundary,
-        comparison: structuredClone(obligation.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: structuredClone(environment.definition),
-        },
-        protected_value_policy: obligation.protected_value_policy,
-        completion_effect: obligation.completion_effect,
-    };
-}
-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 assertCanonicalRowsByKey(actual, expected, keyName, code, detail) {
-    const left = new Map(actual.map((item) => [String(item[keyName]), canonicalJson(item)]));
-    const right = new Map(expected.map((item) => [String(item[keyName]), 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-design-target-capabilities.d.ts

@@ -1,14 +0,0 @@
-import type { DesignResourceHandoffPreflightV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-type ContractDesignTarget = DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number]["design_targets"][number];
-type ContractSurfaceBinding = DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number];
-interface ContractDesignTargetBinding {
-    binding: ContractSurfaceBinding;
-    target: ContractDesignTarget;
-}
-interface IndexedHandoffTarget {
-    preflight: DesignResourceHandoffPreflightV1;
-    target: DesignResourceHandoffTargetV1;
-}
-export declare function validateLongTaskDesignTargetCapabilities(contract: DeliveryContractV2, contractTarget: ContractDesignTargetBinding, indexed: IndexedHandoffTarget): void;
-export {};