project-tiny-context-harness 0.11.0 → 0.12.0

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,309 +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));
-        const sourceItems = new Set(expected.flatMap((expectation) => preflight.manifest.fact_rules.find((item) => item.key === expectation.fact_rule_ref)?.source_item_refs ?? []));
-        validateMethodAssertionClaimOwnership(target, assertion.claims, sourceItems, claimsBySourceItem, "v2_verification_method_claim_not_owned", `${target.key}:${binding.method}`);
-        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));
-        validateMethodAssertionClaimOwnership(target, assertion.claims, sourceItems, claimsBySourceItem, "verification_method_claim_not_owned", `${target.key}:${binding.method}`);
-        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 validateMethodAssertionClaimOwnership(target, methodClaims, sourceItems, claimsBySourceItem, code, detail) {
-    const allowedClaims = new Set(target.claim_refs);
-    for (const sourceItemRef of sourceItems)
-        for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
-            allowedClaims.add(claimRef);
-    for (const claimRef of methodClaims)
-        if (!allowedClaims.has(claimRef))
-            invalid(code, `${detail}:${claimRef}`);
-}
-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 {};

package/dist/lib/long-task-design-target-capabilities.js

@@ -1,126 +0,0 @@
-const METHOD_CAPABILITIES = {
-    responsive_reflow: "viewport-control",
-    motion_timeline: "motion-observation",
-    accessibility_semantics: "assistive-technology",
-    accessibility_navigation: "assistive-technology",
-    accessibility_visual: "assistive-technology",
-    localization: "localization-control",
-    system_ui: "system-ui-observation",
-    haptic_feedback: "haptic-output",
-    sound_feedback: "audio-output",
-};
-const INPUT_CAPABILITIES = {
-    mouse: "pointer-input",
-    pointer: "pointer-input",
-    trackpad: "pointer-input",
-    keyboard: "keyboard-input",
-    touch: "touch-input",
-    pen: "touch-input",
-    stylus: "touch-input",
-    "screen-reader": "assistive-technology",
-    "voice-control": "assistive-technology",
-    "switch-control": "assistive-technology",
-};
-const CONDITION_RULES = [
-    {
-        capability: "assistive-technology",
-        applies: (item) => item.assistive_technology !== "not-applicable",
-    },
-    {
-        capability: "reduced-motion",
-        applies: (item) => item.motion === "reduced",
-    },
-    {
-        capability: "reduced-transparency",
-        applies: (item) => item.transparency === "reduced",
-    },
-    {
-        capability: "increased-contrast",
-        applies: (item) => item.contrast === "increased",
-    },
-    {
-        capability: "bold-text-control",
-        applies: (item) => item.bold_text === "enabled",
-    },
-    {
-        capability: "button-shapes-control",
-        applies: (item) => item.button_shapes === "enabled",
-    },
-    {
-        capability: "system-ui-observation",
-        applies: (item) => item.system_ui !== "not-applicable",
-    },
-    {
-        capability: "ime-control",
-        applies: (item) => item.ime !== "not-applicable",
-    },
-    {
-        capability: "permission-control",
-        applies: (item) => item.permission !== "not-applicable",
-    },
-    {
-        capability: "network-state-control",
-        applies: (item) => item.connectivity !== "not-applicable",
-    },
-    {
-        capability: "lifecycle-control",
-        applies: (item) => item.lifecycle !== "not-applicable",
-    },
-];
-export function validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexed) {
-    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}`);
-    const required = requiredTargetCapabilities(contractTarget.target, indexed);
-    for (const capability of required)
-        if (!executionTarget.capabilities.includes(capability))
-            invalid("execution_target_capability_missing", `${contractTarget.target.key}:${executionTarget.key}:${capability}`);
-}
-function requiredTargetCapabilities(target, indexed) {
-    const required = new Set();
-    addMethodCapabilities(required, target);
-    const conditions = indexed.target.condition_refs.map((conditionRef) => indexed.preflight.handoff.conditions.find((item) => item.key === conditionRef));
-    addVaryingConditionCapabilities(required, conditions);
-    addPerConditionCapabilities(required, conditions);
-    return required;
-}
-function addMethodCapabilities(required, target) {
-    for (const binding of target.verification_method_bindings) {
-        const capability = METHOD_CAPABILITIES[binding.method];
-        if (capability)
-            required.add(capability);
-    }
-}
-function addVaryingConditionCapabilities(required, conditions) {
-    addIfVaries(required, conditions, "viewport-control", (item) => item.viewport.key);
-    addIfSome(required, conditions, "pixel-density-observation", (item) => item.density.key !== "not-applicable");
-    addIfSome(required, conditions, "safe-area-observation", (item) => item.safe_area.key !== "not-applicable");
-    addIfVaries(required, conditions, "color-scheme-control", (item) => item.color_scheme);
-    addIfVaries(required, conditions, "text-scale-control", (item) => item.text_scale.key);
-    addIfVaries(required, conditions, "localization-control", (item) => item.locale);
-    addIfSome(required, conditions, "rtl-control", (item) => item.direction === "rtl");
-    addIfVaries(required, conditions, "device-orientation", (item) => item.orientation);
-    addIfVaries(required, conditions, "window-state-control", (item) => item.window_state);
-    addIfVaries(required, conditions, "fold-state-control", (item) => item.fold_state);
-}
-function addPerConditionCapabilities(required, conditions) {
-    for (const condition of conditions) {
-        const inputCapability = INPUT_CAPABILITIES[condition.input_method.toLowerCase()];
-        if (inputCapability)
-            required.add(inputCapability);
-        for (const rule of CONDITION_RULES)
-            if (rule.applies(condition))
-                required.add(rule.capability);
-    }
-}
-function addIfVaries(required, conditions, capability, value) {
-    if (new Set(conditions.map(value)).size > 1)
-        required.add(capability);
-}
-function addIfSome(required, conditions, capability, predicate) {
-    if (conditions.some(predicate))
-        required.add(capability);
-}
-function invalid(code, detail) {
-    throw new Error(`delivery_contract_invalid:design_resource_${code}:${detail}`);
-}

package/dist/lib/long-task-effective-external-takeover.d.ts

@@ -1,15 +0,0 @@
-import type { ClaimApplicabilityV2, CompiledOutcomeV2, DeliveryContractV2, DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-export declare function effectiveBlockingExternalRows(reachability: AcceptanceReachabilityV1 | null | undefined): AcceptanceReachabilityV1["effective_external_routes"];
-export declare function outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome: DeliveryOutcomeV2, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
-export declare function resultApplicabilityEffectivelyExternallyBlocked(reachability: AcceptanceReachabilityV1 | null | undefined, outcomeKey: string, applicabilityRef: string, targetRef: string): boolean;
-export declare function resultApplicabilityProfiles(outcome: Pick<CompiledOutcomeV2, "applicability" | "product">, options?: {
-    target_ref?: string;
-    journey_role?: ClaimApplicabilityV2["journey_role"];
-}): ClaimApplicabilityV2[];
-export declare function outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome: Pick<CompiledOutcomeV2, "key" | "applicability" | "product">, reachability: AcceptanceReachabilityV1 | null | undefined, options?: {
-    target_ref?: string;
-    journey_role?: ClaimApplicabilityV2["journey_role"];
-}): boolean;
-export declare function outcomeResultFullyEffectivelyExternallyBlocked(outcome: Pick<CompiledOutcomeV2, "key" | "applicability" | "product">, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
-export declare function allOutcomeResultsFullyEffectivelyExternallyBlocked(contract: Pick<DeliveryContractV2, "outcomes">, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;

package/dist/lib/long-task-effective-external-takeover.js

@@ -1,109 +0,0 @@
-import { claimObligationRef, sameSet, } from "./long-task-acceptance-reachability-helpers.js";
-export function effectiveBlockingExternalRows(reachability) {
-    return (reachability?.effective_external_routes ?? []).filter((row) => row.authority === "external_confirmation" &&
-        row.status === "external_fulfillable" &&
-        row.completion_role === "blocking" &&
-        row.acceptance_effect === "required");
-}
-function effectivePopulationRows(outcomeKey, reachability) {
-    return effectiveBlockingExternalRows(reachability).filter((row) => row.outcome_key === outcomeKey &&
-        row.proof_surface === "population_coverage" &&
-        row.method === "population_set_equality" &&
-        row.fact_ref !== null &&
-        row.proof_ref !== null &&
-        row.source_obligation_ref === row.proof_ref &&
-        row.required_evidence_capabilities.includes("semantic_fact") &&
-        row.required_evidence_capabilities.includes("population_coverage"));
-}
-function requiredExternalPopulationProofs(outcome, localClaimRef) {
-    return outcome.semantic_fact_bindings.facts
-        .filter((binding) => binding.claim_ref === localClaimRef)
-        .flatMap((factBinding) => outcome.semantic_fact_bindings.proofs
-        .filter((proofBinding) => proofBinding.fact_ref === factBinding.fact_ref &&
-        proofBinding.authority === "external_confirmation" &&
-        proofBinding.method === "population_set_equality" &&
-        proofBinding.proof_surface === "population_coverage")
-        .map((proofBinding) => ({
-        factBinding,
-        proofBinding,
-        confirmationRef: proofBinding.authority === "external_confirmation"
-            ? proofBinding.confirmation_ref
-            : null,
-    })));
-}
-function populationProofRequirementEffectivelyBlocked(outcome, requirement, rows) {
-    const { factBinding, proofBinding, confirmationRef } = requirement;
-    const profile = outcome.applicability.find((candidate) => candidate.key === factBinding.applicability_ref);
-    if (!profile)
-        return false;
-    return (rows.filter((row) => row.claim_ref === `${outcome.key}.${factBinding.claim_ref}` &&
-        row.local_claim_ref === factBinding.claim_ref &&
-        row.applicability_ref === factBinding.applicability_ref &&
-        row.target_ref === profile.target_ref &&
-        row.fact_ref === factBinding.fact_ref &&
-        row.proof_ref === proofBinding.proof_ref &&
-        row.source_obligation_ref === proofBinding.proof_ref &&
-        row.method === proofBinding.method &&
-        row.proof_surface === proofBinding.proof_surface &&
-        row.confirmation_ref === confirmationRef &&
-        sameSet(row.required_evidence_capabilities, proofBinding.evidence_capabilities)).length === 1);
-}
-function populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows) {
-    const requirements = requiredExternalPopulationProofs(outcome, localClaimRef);
-    return (requirements.length > 0 &&
-        requirements.every((requirement) => populationProofRequirementEffectivelyBlocked(outcome, requirement, rows)));
-}
-export function outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome, reachability) {
-    const population = outcome.acceptance.population;
-    if (!population?.claims.length)
-        return false;
-    const rows = effectivePopulationRows(outcome.key, reachability);
-    return population.claims.every((localClaimRef) => populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows));
-}
-function effectiveBlockingResultRows(reachability, outcomeKey) {
-    const claimRef = `${outcomeKey}.result`;
-    return effectiveBlockingExternalRows(reachability).filter((row) => {
-        const ordinaryObligationRef = claimObligationRef(claimRef, row.applicability_ref, row.proof_surface);
-        return (row.outcome_key === outcomeKey &&
-            row.claim_ref === claimRef &&
-            row.local_claim_ref === "result" &&
-            row.fact_ref === null &&
-            row.proof_ref === null &&
-            row.source_obligation_ref === ordinaryObligationRef);
-    });
-}
-export function resultApplicabilityEffectivelyExternallyBlocked(reachability, outcomeKey, applicabilityRef, targetRef) {
-    const rows = effectiveBlockingResultRows(reachability, outcomeKey).filter((row) => row.applicability_ref === applicabilityRef &&
-        row.target_ref === targetRef);
-    return rows.length === 1;
-}
-export function resultApplicabilityProfiles(outcome, options = {}) {
-    const profiles = new Map(outcome.applicability.map((profile) => [profile.key, profile]));
-    return outcome.product.result_applicability_refs
-        .map((ref) => profiles.get(ref))
-        .filter((profile) => Boolean(profile))
-        .filter((profile) => (options.target_ref === undefined ||
-        profile.target_ref === options.target_ref) &&
-        (options.journey_role === undefined ||
-            profile.journey_role === options.journey_role));
-}
-export function outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability, options = {}) {
-    const profiles = resultApplicabilityProfiles(outcome, options);
-    if (!profiles.length)
-        return false;
-    const requiredRefs = new Set(profiles.map((profile) => profile.key));
-    const rows = effectiveBlockingResultRows(reachability, outcome.key).filter((row) => requiredRefs.has(row.applicability_ref));
-    return (rows.length === profiles.length &&
-        profiles.every((profile) => rows.filter((row) => row.applicability_ref === profile.key &&
-            row.target_ref === profile.target_ref).length === 1));
-}
-export function outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability) {
-    if (resultApplicabilityProfiles(outcome).length !==
-        outcome.product.result_applicability_refs.length)
-        return false;
-    return outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability);
-}
-export function allOutcomeResultsFullyEffectivelyExternallyBlocked(contract, reachability) {
-    return (contract.outcomes.length > 0 &&
-        contract.outcomes.every((outcome) => outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability)));
-}

package/dist/lib/long-task-effective-external-ui-takeover.d.ts

@@ -1,5 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-type DeliveryOutcomeV2 = DeliveryContractV2["outcomes"][number];
-export declare function outcomeUiProofFullyEffectivelyExternallyBlocked(contract: DeliveryContractV2, outcome: DeliveryOutcomeV2, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
-export {};