project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/long-task-claim-definitions.js

@@ -20,6 +20,16 @@ export function generateClaims(outcome) {
         claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing", [], item.applicability_refs, "negative"));
     for (const item of outcome.technical.obligations)
         claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces, item.applicability_refs));
+    for (const binding of outcome.semantic_fact_bindings?.facts ?? []) {
+        const requiredSurfaces = [
+            ...new Set((outcome.semantic_fact_bindings?.proofs ?? [])
+                .filter((proof) => proof.fact_ref === binding.fact_ref)
+                .map((proof) => proof.proof_surface)),
+        ];
+        claims.push(claim(outcome.key, binding.claim_ref, "semantic_fact", requiredSurfaces, [
+            binding.applicability_ref,
+        ]));
+    }
     for (const item of outcome.technical.forbidden_shortcuts)
         claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut", [], item.applicability_refs, "negative"));
     return claims;
@@ -38,7 +48,9 @@ export function validateGlobalProofPolarity(claim, proof) {
 export function validateProofSurface(claim, proof, outcomeKey) {
     if (proof.polarity !== claim.required_polarity)
         fail("claim_proof_polarity_mismatch", `${outcomeKey}:${claim.local_key}:${proof.polarity}:${claim.required_polarity}`);
-    if ((claim.kind === "requirement" || claim.kind === "obligation") &&
+    if ((claim.kind === "requirement" ||
+        claim.kind === "obligation" ||
+        claim.kind === "semantic_fact") &&
         claim.required_proof_surfaces.length > 0 &&
         !claim.required_proof_surfaces.includes(proof.proof_surface))
         fail(`${claim.kind}_proof_surface_mismatch`, `${outcomeKey}:${claim.local_key}:${proof.proof_surface}`);

package/dist/lib/long-task-claims.js

@@ -105,7 +105,8 @@ function compileOutcomeScope(contract, outcomeKey, claims, profiles, outcomeKeys
         if (proof.assertion.observation === "playwright.passed" &&
             (claim.kind === "requirement" ||
                 claim.kind === "control" ||
-                claim.kind === "control_relation"))
+                claim.kind === "control_relation" ||
+                claim.kind === "semantic_fact"))
             fail("fine_grained_claim_requires_ac_observation", `${outcomeKey}:${claim.local_key}`);
         const applicabilityRef = validateAssertionApplicability(claim.applicability_refs, proof, profiles, outcomeKey);
         const claimProof = {
@@ -119,6 +120,27 @@ function compileOutcomeScope(contract, outcomeKey, claims, profiles, outcomeKeys
         validateClaimAssertionOperator(claim, proof.assertion, proof.check.proof_surface, outcomeKey, proof.check.key);
         addProof(proofs, claimKey, claimProof);
     }
+    for (const binding of outcome.semantic_fact_bindings.proofs) {
+        if (binding.authority !== "external_confirmation")
+            continue;
+        const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
+        if (!factBinding)
+            fail("semantic_fact_external_fact_binding_missing", `${outcomeKey}:${binding.proof_ref}:${binding.fact_ref}`);
+        const claim = claimMap.get(factBinding.claim_ref);
+        if (!claim)
+            fail("semantic_fact_external_claim_unknown", `${outcomeKey}:${factBinding.claim_ref}`);
+        const confirmation = contract.global.acceptance.external_confirmations.find((item) => item.key === binding.confirmation_ref);
+        const fullClaim = `${outcomeKey}.${factBinding.claim_ref}`;
+        if (!confirmation || !confirmation.impact_claims.includes(fullClaim))
+            fail("semantic_fact_external_confirmation_invalid", `${outcomeKey}:${binding.confirmation_ref}:${fullClaim}`);
+        addProof(proofs, factBinding.claim_ref, {
+            check_key: `EXTERNAL.${binding.confirmation_ref}`,
+            assertion_key: null,
+            polarity: "positive",
+            proof_surface: binding.proof_surface,
+            applicability_ref: factBinding.applicability_ref,
+        });
+    }
     validatePopulationReferences(outcome, claimMap);
     validateCounterfactualReferences(outcome, claimMap);
     validateProfileUse(outcomeKey, profiles, claims);

package/dist/lib/long-task-contract-types.d.ts

@@ -3,6 +3,7 @@ import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./l
 import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
 import type { ApplicableKeyedStatementV2, CheckExecutionTargetV2, ClaimApplicabilityV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
+import type { SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -195,6 +196,7 @@ export interface DeliveryOutcomeV2 {
     stage: string;
     depends_on: string[];
     applicability: ClaimApplicabilityV2[];
+    semantic_fact_bindings: SemanticFactOutcomeBindingsV2;
     product: {
         observable_result: string;
         result_applicability_refs: string[];
@@ -226,6 +228,7 @@ export interface DeliveryOutcomeV2 {
 }
 export interface DeliveryContractV2 {
     schema_version: "long-task-delivery-v2";
+    semantic_fact_manifest: SemanticFactManifestRefV2;
     task: {
         id: string;
         title: string;

package/dist/lib/long-task-delivery-compiler.js

@@ -129,6 +129,7 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         authority_materials: authorityMaterials,
         authority_revision: authorityRevision,
         claim_coverage: claims.summary,
+        semantic_fact_manifest: contract.semantic_fact_manifest,
         task: contract.task,
         risk: contract.risk,
         source_claims: contract.source_claims,

package/dist/lib/long-task-delivery-parser.js

@@ -6,6 +6,7 @@ import { parseOutcome, parseOutcomeFragment, safeFragmentPath, } from "./long-ta
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { array, literal, object, parseSourceClaims, strings, } from "./long-task-delivery-shape.js";
 import { parseGlobal, parseRisk, parseStages, parseTask, } from "./long-task-root-shape.js";
+import { parseSemanticFactManifestRef } from "./long-task-semantic-fact-shape.js";
 import { repositoryRoot } from "./long-task-workspace.js";
 import { assertNoSemanticDriftMigration, semanticDriftMigrationFields, } from "./long-task-semantic-drift-migration.js";
 export const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
@@ -77,12 +78,21 @@ function parseRoot(raw, bundle) {
             "long-task-delivery-v1")
         throw new Error("long_task_delivery_v1_retired_use_v2");
     assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
-    return object(decoded, "$", ["schema_version", "task", "source_claims", "stages", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
+    return object(decoded, "$", [
+        "schema_version",
+        "semantic_fact_manifest",
+        "task",
+        "source_claims",
+        "stages",
+        "risk",
+        "global",
+    ], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
 }
 function parseContractRoot(root, outcomes) {
     literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");
     return {
         schema_version: "long-task-delivery-v2",
+        semantic_fact_manifest: parseSemanticFactManifestRef(root.semantic_fact_manifest, "semantic_fact_manifest"),
         task: parseTask(root.task),
         source_claims: parseSourceClaims(root.source_claims, "source_claims"),
         stages: parseStages(root.stages),

package/dist/lib/long-task-delivery-types.d.ts

@@ -10,3 +10,4 @@ export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-ui-surface-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";
+export * from "./semantic-fact-types.js";

package/dist/lib/long-task-delivery-types.js

@@ -10,3 +10,4 @@ export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-ui-surface-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";
+export * from "./semantic-fact-types.js";

package/dist/lib/long-task-delivery-validation.js

@@ -76,6 +76,23 @@ function validateUniqueKeys(contract, report) {
         ...contract.global.technical.forbidden_shortcuts,
     ].map((item) => item.key), "global_constraint_key_duplicate", report);
     for (const outcome of contract.outcomes) {
+        if (outcome.semantic_fact_bindings.manifest_ref !==
+            contract.semantic_fact_manifest.key)
+            issue(report, "semantic_fact_manifest_ref_mismatch", outcome.key);
+        if (!outcome.semantic_fact_bindings.facts.length)
+            issue(report, "semantic_fact_binding_required", outcome.key);
+        if (!outcome.semantic_fact_bindings.proofs.length)
+            issue(report, "semantic_fact_proof_binding_required", outcome.key);
+        unique(outcome.semantic_fact_bindings.facts.map((item) => item.fact_ref), `semantic_fact_ref_duplicate:${outcome.key}`, report);
+        unique(outcome.semantic_fact_bindings.facts.map((item) => item.claim_ref), `semantic_fact_claim_duplicate:${outcome.key}`, report);
+        unique(outcome.semantic_fact_bindings.proofs.map((item) => item.proof_ref), `semantic_fact_proof_duplicate:${outcome.key}`, report);
+        const semanticFacts = new Set(outcome.semantic_fact_bindings.facts.map((item) => item.fact_ref));
+        for (const proof of outcome.semantic_fact_bindings.proofs)
+            if (!semanticFacts.has(proof.fact_ref))
+                issue(report, "semantic_fact_proof_fact_unknown", `${outcome.key}:${proof.proof_ref}:${proof.fact_ref}`);
+        for (const fact of semanticFacts)
+            if (!outcome.semantic_fact_bindings.proofs.some((proof) => proof.fact_ref === fact))
+                issue(report, "semantic_fact_proof_required", `${outcome.key}:${fact}`);
         unique(outcome.acceptance.checks.map((check) => check.key), `check_key_duplicate:${outcome.key}`, report);
         unique(outcome.product.requirements.map((item) => item.key), `requirement_key_duplicate:${outcome.key}`, report);
         unique(outcome.product.controls.map((control) => control.key), `control_key_duplicate:${outcome.key}`, report);

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

@@ -2,6 +2,7 @@ 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 { 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);
@@ -18,7 +19,7 @@ export async function validateLongTaskDesignResourceHandoffs(contract, repositor
             invalid("target_handoff_missing", contractTarget.target.key);
         consumed.add(contractTarget.target.key);
         validateTargetIdentity(contractTarget, indexedTarget);
-        validateTargetCapabilities(contract, contractTarget, indexedTarget);
+        validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
         validateCoverageClaims(contract, contractTarget, indexedTarget);
         validateBlockerBindings(contract, contractTarget, indexedTarget);
     }
@@ -68,6 +69,8 @@ function validateCoverageClaims(contract, contractTarget, indexed) {
     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();
@@ -76,7 +79,7 @@ function validateCoverageClaims(contract, contractTarget, indexed) {
             const localClaims = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
             claimsBySourceItem.set(sourceItemRef, localClaims);
         }
-    validateVerificationMethodBindings(target, check, facts, claimsBySourceItem);
+    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]));
@@ -140,8 +143,8 @@ function designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef
         return claimRef.slice(prefix.length);
     });
 }
-function validateVerificationMethodBindings(target, check, facts, claimsBySourceItem) {
-    const expectedMethods = new Set(facts.map((fact) => fact.verification_method));
+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);
@@ -155,7 +158,7 @@ function validateVerificationMethodBindings(target, check, facts, claimsBySource
         if (!assertion)
             invalid("verification_method_assertion_unknown", `${target.key}:${binding.method}:${binding.assertion_ref}`);
         const sourceItems = new Set(facts
-            .filter((fact) => fact.verification_method === binding.method)
+            .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) ?? [])
@@ -167,15 +170,67 @@ function validateVerificationMethodBindings(target, check, facts, claimsBySource
         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) => fact.verification_method === binding.method &&
-                fact.condition_ref === artifact.condition_key)
+                .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"];
@@ -188,37 +243,6 @@ function requiredCapabilities(method) {
         ];
     return ["design_method", "design_conformance", "target_runtime"];
 }
-function validateTargetCapabilities(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 = new Set();
-    for (const method of contractTarget.target.verification_method_bindings.map((item) => item.method)) {
-        if (method === "responsive_reflow")
-            required.add("viewport-control");
-        if (method === "motion_timeline")
-            required.add("motion-observation");
-        if (method === "accessibility_semantics")
-            required.add("assistive-technology");
-    }
-    for (const conditionRef of indexed.target.condition_refs) {
-        const condition = indexed.preflight.handoff.conditions.find((item) => item.key === conditionRef);
-        const input = condition.input_methods[0].toLowerCase();
-        if (["mouse", "pointer", "trackpad"].includes(input))
-            required.add("pointer-input");
-        if (input === "keyboard")
-            required.add("keyboard-input");
-        if (["touch", "pen", "stylus"].includes(input))
-            required.add("touch-input");
-        if (["screen-reader", "voice-control", "switch-control"].includes(input))
-            required.add("assistive-technology");
-        if (condition.motion === "reduced")
-            required.add("reduced-motion");
-    }
-    for (const capability of required)
-        if (!executionTarget.capabilities.includes(capability))
-            invalid("execution_target_capability_missing", `${contractTarget.target.key}:${executionTarget.key}:${capability}`);
-}
 function assertSameSet(actual, expected, code, detail) {
     const left = [...new Set(actual)].sort();
     const right = [...new Set(expected)].sort();

package/dist/lib/long-task-design-target-capabilities.d.ts

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

@@ -0,0 +1,126 @@
+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-evidence-capability-codec.d.ts

@@ -1,2 +1,96 @@
 import type { EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
 export declare function decodeEvidenceCapabilityRecords(value: unknown): EvidenceCapabilityRecordV2[];
+export declare function decodeDesignFactResults(value: unknown, label: string): {
+    fact_ref: string;
+    subject_ref: string;
+    variation_ref: string;
+    property_ref: string;
+    actual_observation: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: {
+            kind: "asset_ref" | "custom" | "image_region" | "json_pointer" | "semantic_node" | "timeline_sample" | "trace_event";
+            value: string;
+        };
+        value_sha256: string;
+        sensitivity: "plain" | "protected";
+        redaction: {
+            policy_ref: string;
+            representation: "digest_only" | "redacted_structured";
+            raw_persisted: false;
+        } | null;
+    };
+    actual_environment: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: {
+            kind: "asset_ref" | "custom" | "image_region" | "json_pointer" | "semantic_node" | "timeline_sample" | "trace_event";
+            value: string;
+        };
+        value_sha256: string;
+    };
+    expected: {
+        locator: {
+            resource_ref: string;
+            kind: "css_custom_property" | "css_declaration" | "css_selector" | "html_attribute" | "html_inner_html" | "html_selector" | "javascript_export" | "json_pointer" | "markdown_anchor" | "svg_attribute" | "svg_inner_xml" | "svg_selector" | "whole_resource";
+            value: string;
+        };
+        sha256: string;
+    };
+    comparison: {
+        artifact_path: string;
+        artifact_sha256: string;
+        locator: {
+            kind: "asset_ref" | "custom" | "image_region" | "json_pointer" | "semantic_node" | "timeline_sample" | "trace_event";
+            value: string;
+        };
+        result_sha256: string;
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: {
+            locator: {
+                resource_ref: string;
+                kind: "css_custom_property" | "css_declaration" | "css_selector" | "html_attribute" | "html_inner_html" | "html_selector" | "javascript_export" | "json_pointer" | "markdown_anchor" | "svg_attribute" | "svg_inner_xml" | "svg_selector" | "whole_resource";
+                value: string;
+            };
+            sha256: string;
+        };
+        tolerance: {
+            locator: {
+                resource_ref: string;
+                kind: "css_custom_property" | "css_declaration" | "css_selector" | "html_attribute" | "html_inner_html" | "html_selector" | "javascript_export" | "json_pointer" | "markdown_anchor" | "svg_attribute" | "svg_inner_xml" | "svg_selector" | "whole_resource";
+                value: string;
+            };
+            sha256: string;
+        } | null;
+        mask: {
+            locator: {
+                resource_ref: string;
+                kind: "css_custom_property" | "css_declaration" | "css_selector" | "html_attribute" | "html_inner_html" | "html_selector" | "javascript_export" | "json_pointer" | "markdown_anchor" | "svg_attribute" | "svg_inner_xml" | "svg_selector" | "whole_resource";
+                value: string;
+            };
+            sha256: string;
+        } | null;
+        passed: boolean;
+    };
+    verdict: "failed" | "passed";
+    oracle: {
+        key: string;
+        trust: "frozen_executable" | "named_external_tcb";
+        identity: string;
+        version: string;
+        sha256: string | null;
+    };
+    environment: {
+        key: string;
+        identity: string;
+        definition: {
+            locator: {
+                resource_ref: string;
+                kind: "css_custom_property" | "css_declaration" | "css_selector" | "html_attribute" | "html_inner_html" | "html_selector" | "javascript_export" | "json_pointer" | "markdown_anchor" | "svg_attribute" | "svg_inner_xml" | "svg_selector" | "whole_resource";
+                value: string;
+            };
+            sha256: string;
+        };
+    };
+}[];