project-tiny-context-harness 0.8.4 → 0.8.6

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

@@ -0,0 +1,67 @@
+import { designFactComparatorSupportsMethod, designFactEvidenceSupportsMethod, designFactMethodIsCompatible, designFactOracleSupportsMethod, } from "./design-resource-fact-policy.js";
+import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceProofObligations(handoff, resources, targets, evidence) {
+    const facts = new Map(handoff.facts.map((item) => [item.key, item]));
+    const oracles = new Map(handoff.oracles.map((item) => [item.key, item]));
+    const environments = new Map(handoff.environments.map((item) => [item.key, item]));
+    const proofByFact = new Map();
+    const factMethodPairs = [];
+    for (const proof of handoff.proof_obligations) {
+        validateProofReferences(proof, facts, oracles, environments);
+        validateProofMethod(proof, facts.get(proof.fact_ref), oracles.get(proof.oracle_ref), evidence);
+        validateProofResources(proof, facts.get(proof.fact_ref), environments, resources, targets);
+        validateProofComparison(proof);
+        proofByFact.set(proof.fact_ref, (proofByFact.get(proof.fact_ref) ?? 0) + 1);
+        factMethodPairs.push(`${proof.fact_ref}\0${proof.method}`);
+    }
+    requireUniqueDesignResourceValues(factMethodPairs, "fact_verification_method_obligation_duplicate");
+    for (const fact of handoff.facts)
+        if (!proofByFact.has(fact.key))
+            invalidDesignResourceHandoff("fact_verification_method_required", fact.key);
+    for (const environment of handoff.environments)
+        requireKnownDesignResourceRef(resources, environment.definition.locator.resource_ref, "environment_resource");
+}
+function validateProofReferences(proof, facts, oracles, environments) {
+    requireKnownDesignResourceRef(facts, proof.fact_ref, "proof_fact");
+    requireKnownDesignResourceRef(oracles, proof.oracle_ref, "proof_oracle");
+    requireKnownDesignResourceRef(environments, proof.environment_ref, "proof_environment");
+}
+function validateProofMethod(proof, fact, oracle, evidence) {
+    if (!designFactMethodIsCompatible(fact.dimension, proof.method))
+        invalidDesignResourceHandoff("proof_verification_method_incompatible", `${proof.key}:${fact.dimension}:${proof.method}`);
+    if (!fact.evidence_refs.some((ref) => designFactEvidenceSupportsMethod(proof.method, evidence.get(ref).kind)))
+        invalidDesignResourceHandoff("proof_method_evidence_missing", `${proof.key}:${proof.fact_ref}:${proof.method}`);
+    if (!designFactComparatorSupportsMethod(proof.method, proof.comparison.comparator))
+        invalidDesignResourceHandoff("proof_comparator_method_incompatible", `${proof.key}:${proof.method}:${proof.comparison.comparator}`);
+    if (!designFactOracleSupportsMethod(proof.method, oracle.capability_refs))
+        invalidDesignResourceHandoff("proof_oracle_capability_missing", `${proof.key}:${proof.oracle_ref}:${proof.method}`);
+}
+function validateProofResources(proof, fact, environments, resources, targets) {
+    const target = targets.get(fact.target_ref);
+    const environmentResourceRef = environments.get(proof.environment_ref)
+        .definition.locator.resource_ref;
+    if (!target.resource_refs.includes(environmentResourceRef))
+        invalidDesignResourceHandoff("proof_environment_outside_target", `${proof.key}:${proof.environment_ref}:${environmentResourceRef}`);
+    for (const located of [
+        proof.comparison.parameters,
+        proof.comparison.tolerance,
+        proof.comparison.mask,
+    ])
+        if (located) {
+            requireKnownDesignResourceRef(resources, located.locator.resource_ref, "proof_resource");
+            if (!target.resource_refs.includes(located.locator.resource_ref))
+                invalidDesignResourceHandoff("proof_resource_outside_target", `${proof.key}:${located.locator.resource_ref}`);
+        }
+}
+function validateProofComparison(proof) {
+    if (proof.comparison.mode === "exact" &&
+        (proof.comparison.tolerance !== null || proof.comparison.mask !== null))
+        invalidDesignResourceHandoff("proof_exact_tolerance_forbidden", proof.key);
+    if (proof.comparison.mode === "tolerance" &&
+        proof.comparison.tolerance === null)
+        invalidDesignResourceHandoff("proof_tolerance_required", proof.key);
+    if (proof.comparison.mask !== null &&
+        proof.comparison.comparator !== "pixel_diff" &&
+        !proof.comparison.comparator.startsWith("custom."))
+        invalidDesignResourceHandoff("proof_mask_comparator_incompatible", `${proof.key}:${proof.comparison.comparator}`);
+}

package/dist/lib/design-resource-handoff-validation-resource-closure.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceExactTargetFacts(handoff: DesignResourceHandoffV1): void;
+export declare function validateDesignResourceResourceFactClosure(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>): void;

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

@@ -0,0 +1,88 @@
+import { EXACT_TARGET_FULL_TARGET_METHODS } from "./design-resource-fact-policy.js";
+import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceExactTargetFacts(handoff) {
+    const proofsByFact = new Map();
+    for (const proof of handoff.proof_obligations) {
+        const methods = proofsByFact.get(proof.fact_ref) ?? [];
+        methods.push(proof.method);
+        proofsByFact.set(proof.fact_ref, methods);
+    }
+    for (const target of handoff.targets) {
+        if (target.interpretation !== "exact_target")
+            continue;
+        for (const conditionRef of target.condition_refs)
+            for (const method of EXACT_TARGET_FULL_TARGET_METHODS)
+                if (!hasExactTargetFact(handoff, target.key, conditionRef, method, proofsByFact))
+                    invalidDesignResourceHandoff("exact_target_full_target_fact_missing", `${target.key}:${conditionRef}:${method}`);
+    }
+}
+function hasExactTargetFact(handoff, targetRef, conditionRef, method, proofsByFact) {
+    return handoff.facts.some((fact) => fact.target_ref === targetRef &&
+        fact.condition_ref === conditionRef &&
+        fact.observation_scope === "full_target" &&
+        (proofsByFact.get(fact.key) ?? []).includes(method));
+}
+export function validateDesignResourceResourceFactClosure(handoff, resources, evidence) {
+    const lineageNodes = new Map(handoff.lineage_nodes.map((item) => [item.key, item]));
+    const proofsByFact = new Map(handoff.facts.map((fact) => [
+        fact.key,
+        handoff.proof_obligations.filter((proof) => proof.fact_ref === fact.key),
+    ]));
+    const environments = new Map(handoff.environments.map((environment) => [environment.key, environment]));
+    const closuresByResource = new Map();
+    for (const closure of handoff.resource_fact_closure) {
+        validateResourceClosure(closure, handoff, resources, evidence, lineageNodes, proofsByFact, environments);
+        if (closuresByResource.has(closure.resource_ref))
+            invalidDesignResourceHandoff("resource_fact_closure_duplicate", closure.resource_ref);
+        closuresByResource.set(closure.resource_ref, closure.key);
+    }
+    for (const resource of handoff.resources)
+        if (!closuresByResource.has(resource.key))
+            invalidDesignResourceHandoff("resource_fact_closure_missing", resource.key);
+}
+function validateResourceClosure(closure, handoff, resources, evidence, lineageNodes, proofsByFact, environments) {
+    requireKnownDesignResourceRef(resources, closure.resource_ref, "resource_fact_closure_resource");
+    requireUniqueDesignResourceValues(closure.fact_refs, `resource_fact_closure_fact_ref_duplicate:${closure.key}`);
+    const expected = handoff.facts
+        .filter((fact) => factUsesResource(fact, closure.resource_ref, proofsByFact.get(fact.key) ?? [], environments, lineageNodes, evidence))
+        .map((fact) => fact.key);
+    for (const factRef of closure.fact_refs)
+        if (!handoff.facts.some((fact) => fact.key === factRef))
+            invalidDesignResourceHandoff("resource_fact_closure_fact_unknown", `${closure.key}:${factRef}`);
+    assertSameSet(closure.fact_refs, expected, "resource_fact_closure_mismatch", closure.resource_ref);
+    validateClosureDisposition(closure, resources.get(closure.resource_ref));
+}
+function factUsesResource(fact, resourceRef, proofs, environments, lineageNodes, evidence) {
+    const proofResources = proofs.flatMap((proof) => [
+        proof.comparison.parameters.locator.resource_ref,
+        proof.comparison.tolerance?.locator.resource_ref,
+        proof.comparison.mask?.locator.resource_ref,
+        environments.get(proof.environment_ref)?.definition.locator.resource_ref,
+    ]);
+    const lineageResources = [
+        ...fact.lineage.token_chain_refs,
+        ...fact.lineage.override_chain_refs,
+    ].map((ref) => lineageNodes.get(ref)?.value.locator.resource_ref);
+    return (fact.value.locator.resource_ref === resourceRef ||
+        fact.lineage.resolved_value.locator.resource_ref === resourceRef ||
+        lineageResources.includes(resourceRef) ||
+        proofResources.includes(resourceRef) ||
+        fact.evidence_refs.some((evidenceRef) => evidence.get(evidenceRef)?.resource_ref === resourceRef));
+}
+function validateClosureDisposition(closure, resource) {
+    if (closure.disposition === "material_with_facts" &&
+        closure.fact_refs.length === 0)
+        invalidDesignResourceHandoff("resource_fact_closure_facts_required", closure.key);
+    if (closure.disposition === "supporting_only" && closure.fact_refs.length > 0)
+        invalidDesignResourceHandoff("supporting_only_resource_fact_forbidden", closure.key);
+    if (resource.role !== "supporting" &&
+        closure.disposition !== "material_with_facts")
+        invalidDesignResourceHandoff("target_resource_fact_closure_required", `${closure.key}:${resource.role}`);
+}
+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]))
+        invalidDesignResourceHandoff(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}

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

@@ -1,29 +1,38 @@
 import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
 export function validateDesignResourceScope(handoff) {
-    const surfaceStableKeys = new Set(handoff.subjects
-        .filter((subject) => subject.kind === "surface")
-        .flatMap((subject) => subject.stable_keys));
+    const scopedSurfaceKeys = new Set(handoff.scope.surface_keys);
+    const surfaceSubjects = handoff.subjects.filter((subject) => subject.kind === "surface");
+    const surfaceStableKeys = new Set(surfaceSubjects.flatMap((subject) => subject.stable_keys));
     for (const surfaceKey of handoff.scope.surface_keys)
         if (!surfaceStableKeys.has(surfaceKey))
             invalidDesignResourceHandoff("scope_surface_subject_missing", surfaceKey);
+    for (const subject of surfaceSubjects)
+        if (!subject.stable_keys.some((key) => scopedSurfaceKeys.has(key)))
+            invalidDesignResourceHandoff("scope_surface_subject_outside_scope", subject.key);
 }
 export function validateDesignResourceConditions(handoff) {
+    const viewportProfiles = new Map();
+    const densityProfiles = new Map();
+    const safeAreaProfiles = new Map();
+    const textScaleProfiles = new Map();
     for (const condition of handoff.conditions) {
-        for (const [name, values] of [
-            ["modes", condition.modes],
-            ["states", condition.states],
-            ["content_cases", condition.content_cases],
-            ["input_methods", condition.input_methods],
-        ]) {
-            requireNonemptyDesignResourceValues(values, `condition_${name}_required:${condition.key}`);
-            requireUniqueDesignResourceValues(values, `condition_${name}_duplicate:${condition.key}`);
-            if (values.length !== 1)
-                invalidDesignResourceHandoff(`condition_${name}_must_be_atomic`, condition.key);
-        }
+        requireConsistentConditionProfile(viewportProfiles, condition.viewport.key, `${condition.viewport.width}\0${condition.viewport.height}\0${condition.viewport.unit}`, "viewport", condition.key);
+        requireConsistentConditionProfile(densityProfiles, condition.density.key, String(condition.density.pixel_ratio), "density", condition.key);
+        requireConsistentConditionProfile(safeAreaProfiles, condition.safe_area.key, `${condition.safe_area.top}\0${condition.safe_area.right}\0${condition.safe_area.bottom}\0${condition.safe_area.left}\0${condition.safe_area.unit}`, "safe_area", condition.key);
+        requireConsistentConditionProfile(textScaleProfiles, condition.text_scale.key, String(condition.text_scale.multiplier), "text_scale", condition.key);
+        requireUniqueDesignResourceValues(condition.custom_axes.map((item) => item.axis_ref), `condition_custom_axis_duplicate:${condition.key}`);
+        requireUniqueDesignResourceValues(condition.custom_axes.map((item) => `${item.axis_ref}\0${item.value_ref}`), `condition_custom_axis_value_duplicate:${condition.key}`);
     }
 }
+function requireConsistentConditionProfile(profiles, key, definition, profileKind, conditionKey) {
+    const existing = profiles.get(key);
+    if (existing !== undefined && existing !== definition)
+        invalidDesignResourceHandoff(`condition_${profileKind}_profile_conflict`, `${key}:${conditionKey}`);
+    profiles.set(key, definition);
+}
 export function validateDesignResourceSubjects(handoff, targets) {
     const stableKeys = new Set();
+    const subjects = new Map(handoff.subjects.map((subject) => [subject.key, subject]));
     for (const subject of handoff.subjects) {
         requireNonemptyDesignResourceValues(subject.stable_keys, `subject_stable_keys_required:${subject.key}`);
         requireUniqueDesignResourceValues(subject.stable_keys, `subject_stable_key_duplicate:${subject.key}`);
@@ -36,6 +45,23 @@ export function validateDesignResourceSubjects(handoff, targets) {
                 invalidDesignResourceHandoff("subject_stable_key_ambiguous", stableKey);
             stableKeys.add(stableKey);
         }
+        for (const ref of [
+            subject.parent_ref,
+            subject.instance_of_ref,
+            subject.override_of_ref,
+            subject.family_ref,
+            subject.portal_host_ref,
+        ])
+            if (ref !== null && !subjects.has(ref))
+                invalidDesignResourceHandoff("subject_hierarchy_ref_unknown", `${subject.key}:${ref}`);
+        requireUniqueDesignResourceValues(subject.census_refs, `subject_census_ref_duplicate:${subject.key}`);
+        requireUniqueDesignResourceValues(subject.relation_endpoints.map((item) => item.role), `subject_relation_endpoint_role_duplicate:${subject.key}`);
+        if (subject.presence === "always" && subject.presence_rule_ref !== null)
+            invalidDesignResourceHandoff("subject_always_presence_rule_forbidden", subject.key);
+        if (subject.presence !== "always" && subject.presence_rule_ref === null)
+            invalidDesignResourceHandoff("subject_dynamic_presence_rule_required", subject.key);
+        if (subject.presence === "virtualized" && subject.population_ref === null)
+            invalidDesignResourceHandoff("subject_virtualized_population_required", subject.key);
     }
 }
 export function validateDesignResourceTargets(handoff, resources, conditions) {
@@ -60,6 +86,9 @@ function validateTargetSourceProfile(target, resources) {
     requireUniqueDesignResourceValues(profile.dependency_resource_refs, `source_profile_dependency_resource_ref_duplicate:${target.key}`);
     for (const ref of profile.dependency_resource_refs)
         requireKnownDesignResourceRef(resources, ref, "source_profile_dependency_resource");
+    requireKnownDesignResourceRef(resources, profile.fact_manifest_resource_ref, "source_profile_fact_manifest_resource");
+    if (!profile.dependency_resource_refs.includes(profile.fact_manifest_resource_ref))
+        invalidDesignResourceHandoff("source_profile_fact_manifest_dependency_missing", target.key);
     if (profile.dependency_resource_refs.includes(profile.entry_resource_ref))
         invalidDesignResourceHandoff("source_profile_entry_repeated_as_dependency", target.key);
     const declared = [

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

@@ -2,6 +2,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
 import { validateDesignResourceFiles } from "./design-resource-handoff-file-validation.js";
+import { loadAndValidateDesignResourceFactManifests } from "./design-resource-fact-manifest-validation.js";
 import { validateDesignResourceFacts } from "./design-resource-handoff-validation-facts.js";
 import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
 import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
@@ -14,6 +15,7 @@ export async function preflightDesignResourceHandoff(repository, handoffPath) {
     validateDesignResourceHandoffSemantics(parsed);
     const resourceHashes = await validateResourceIntegrity(repository, parsed);
     await validateDesignResourceFiles(repository, parsed);
+    const manifests = await loadAndValidateDesignResourceFactManifests(repository, parsed);
     const handoff = parsed.handoff;
     return {
         schema_version: "design-resource-handoff-preflight-v1",
@@ -22,11 +24,21 @@ export async function preflightDesignResourceHandoff(repository, handoffPath) {
         resource_hashes: resourceHashes,
         counts: {
             resources: handoff.resources.length,
+            manifests: manifests.size,
+            axis_dispositions: handoff.axis_dispositions.length,
             conditions: handoff.conditions.length,
             subjects: handoff.subjects.length,
+            variations: handoff.variations.length,
+            properties: handoff.properties.length,
+            lineage_nodes: handoff.lineage_nodes.length,
             targets: handoff.targets.length,
             evidence: handoff.evidence.length,
+            fact_cells: handoff.fact_cells.length,
             facts: handoff.facts.length,
+            proof_obligations: handoff.proof_obligations.length,
+            oracles: handoff.oracles.length,
+            environments: handoff.environments.length,
+            asset_bindings: handoff.asset_bindings.length,
             resource_fact_closure: handoff.resource_fact_closure.length,
             coverage: handoff.coverage.length,
             acceptance_blockers: handoff.acceptance_blockers.length,
@@ -37,21 +49,41 @@ export function validateDesignResourceHandoffSemantics(parsed) {
     const { handoff } = parsed;
     requireNonemptyDesignResourceValues(handoff.scope.surface_keys, "scope_surface_keys_required");
     requireNonemptyDesignResourceValues(handoff.resources, "resources_required");
+    requireNonemptyDesignResourceValues(handoff.axis_dispositions, "axis_dispositions_required");
     requireNonemptyDesignResourceValues(handoff.conditions, "conditions_required");
     requireNonemptyDesignResourceValues(handoff.subjects, "subjects_required");
+    requireNonemptyDesignResourceValues(handoff.variation_axis_dispositions, "variation_axis_dispositions_required");
+    requireNonemptyDesignResourceValues(handoff.variations, "variations_required");
+    requireNonemptyDesignResourceValues(handoff.properties, "properties_required");
     requireNonemptyDesignResourceValues(handoff.targets, "targets_required");
     requireNonemptyDesignResourceValues(handoff.evidence, "evidence_required");
+    requireNonemptyDesignResourceValues(handoff.fact_cells, "fact_cells_required");
     requireNonemptyDesignResourceValues(handoff.facts, "facts_required");
+    requireNonemptyDesignResourceValues(handoff.proof_obligations, "proof_obligations_required");
+    requireNonemptyDesignResourceValues(handoff.oracles, "oracles_required");
+    requireNonemptyDesignResourceValues(handoff.environments, "environments_required");
     requireNonemptyDesignResourceValues(handoff.resource_fact_closure, "resource_fact_closure_required");
     requireNonemptyDesignResourceValues(handoff.coverage, "coverage_required");
     requireUniqueDesignResourceValues(handoff.scope.surface_keys, "scope_surface_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.resources, "resource_key_duplicate");
     requireUniqueDesignResourceValues(handoff.resources.map((item) => item.path), "resource_path_duplicate");
+    requireUniqueDesignResourceObjects(handoff.axis_dispositions, "axis_disposition_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.condition_exclusions, "condition_exclusion_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.conditions, "condition_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.subjects, "subject_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.variation_axis_dispositions, "variation_axis_disposition_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.variation_exclusions, "variation_exclusion_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.variations, "variation_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.properties, "property_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.lineage_nodes, "lineage_node_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.targets, "target_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.evidence, "evidence_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.facts, "fact_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.fact_cells, "fact_cell_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.proof_obligations, "proof_obligation_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.oracles, "oracle_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.environments, "environment_key_duplicate");
+    requireUniqueDesignResourceObjects(handoff.asset_bindings, "asset_binding_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.resource_fact_closure, "resource_fact_closure_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.coverage, "coverage_key_duplicate");
     requireUniqueDesignResourceObjects(handoff.acceptance_blockers, "acceptance_blocker_key_duplicate");

package/dist/lib/design-resource-handoff-web-dependency-validation.d.ts

@@ -1,3 +1,4 @@
 import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 import { type DesignResource } from "./design-resource-handoff-file-primitives.js";
-export declare function validateDesignResourceWebDependencyClosure(target: ParsedDesignResourceHandoffV1["handoff"]["targets"][number], resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateDesignResourceImplementationDependencyClosure(target: ParsedDesignResourceHandoffV1["handoff"]["targets"][number], resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare const validateDesignResourceWebDependencyClosure: typeof validateDesignResourceImplementationDependencyClosure;

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { htmlAttributes, isTextResource, } from "./design-resource-handoff-file-primitives.js";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceWebDependencyClosure(target, resources, contents) {
+export function validateDesignResourceImplementationDependencyClosure(target, resources, contents) {
     const declaredPaths = new Set(target.resource_refs.map((ref) => resources.get(ref).path));
     for (const resourceRef of target.resource_refs) {
         const resource = resources.get(resourceRef);
@@ -10,17 +10,23 @@ export function validateDesignResourceWebDependencyClosure(target, resources, co
         const content = contents.get(resourceRef).toString("utf8");
         for (const reference of localDependencyReferences(content, resource.media_type)) {
             const resolved = resolveResourceReference(resource.path, reference);
-            if (!declaredPaths.has(resolved))
+            const declared = resolveDeclaredPath(declaredPaths, resolved);
+            if (declared === null)
                 invalidDesignResourceHandoff("implementation_dependency_undeclared", `${target.key}:${resource.path}:${reference}:${resolved}`);
         }
     }
 }
 function localDependencyReferences(content, mediaType) {
     const values = new Set();
-    if (["text/html", "application/xhtml+xml"].includes(mediaType)) {
+    const markupMediaTypes = [
+        "text/html",
+        "application/xhtml+xml",
+        "image/svg+xml",
+    ];
+    if (markupMediaTypes.includes(mediaType)) {
         for (const tag of content.matchAll(/<(script|img|source|video|audio|track|iframe|embed|input|link|object|use|image)\b([^<>]*)>/giu)) {
             const attributes = htmlAttributes(tag[2]);
-            for (const name of ["src", "href", "poster"])
+            for (const name of ["src", "href", "xlink:href", "poster"])
                 addLocalReference(values, attributes.get(name));
             if (tag[1].toLowerCase() === "object")
                 addLocalReference(values, attributes.get("data"));
@@ -28,8 +34,7 @@ function localDependencyReferences(content, mediaType) {
                 addLocalReference(values, candidate.trim().split(/\s+/u)[0]);
         }
     }
-    if (mediaType === "text/css" ||
-        ["text/html", "application/xhtml+xml"].includes(mediaType))
+    if (mediaType === "text/css" || markupMediaTypes.includes(mediaType))
         for (const match of content.matchAll(/(?:url\(\s*["']?([^"')\s]+)|@import\s+(?:url\(\s*)?["']([^"']+))/giu))
             addLocalReference(values, match[1] ?? match[2]);
     if ([
@@ -40,14 +45,24 @@ function localDependencyReferences(content, mediaType) {
         "text/ecmascript",
         "application/ecmascript",
         "text/html",
+        "application/xhtml+xml",
+        "image/svg+xml",
     ].includes(mediaType)) {
         for (const match of content.matchAll(/(?:\b(?:from|import)\s*|\bimport\s*\(|\brequire\s*\()\s*["']([^"']+)["']/gu))
-            addLocalReference(values, match[1]);
+            addModuleReference(values, match[1]);
         for (const match of content.matchAll(/(?:\bfetch\s*\(|\bnew\s+(?:Shared)?Worker\s*\(|\bnew\s+URL\s*\()\s*["']([^"']+)["']/gu))
             addLocalReference(values, match[1]);
     }
     return values;
 }
+function addModuleReference(values, raw) {
+    if (!raw)
+        return;
+    const value = raw.trim();
+    if (!value.startsWith(".") && !value.startsWith("/"))
+        return;
+    addLocalReference(values, value);
+}
 function addLocalReference(values, raw) {
     if (!raw)
         return;
@@ -68,3 +83,48 @@ function resolveResourceReference(from, reference) {
         invalidDesignResourceHandoff("implementation_dependency_path_unsafe", `${from}:${reference}`);
     return resolved;
 }
+function resolveDeclaredPath(declaredPaths, resolved) {
+    if (declaredPaths.has(resolved))
+        return resolved;
+    const candidates = [
+        ...[
+            ".js",
+            ".jsx",
+            ".mjs",
+            ".cjs",
+            ".ts",
+            ".tsx",
+            ".json",
+            ".css",
+            ".svg",
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".webp",
+            ".avif",
+            ".gif",
+            ".ico",
+            ".woff",
+            ".woff2",
+            ".ttf",
+            ".otf",
+            ".mp4",
+            ".webm",
+            ".mp3",
+            ".wav",
+            ".lottie",
+        ].map((extension) => `${resolved}${extension}`),
+        ...[
+            "index.js",
+            "index.jsx",
+            "index.mjs",
+            "index.ts",
+            "index.tsx",
+            "index.json",
+        ].map((name) => `${resolved}/${name}`),
+    ].filter((candidate) => declaredPaths.has(candidate));
+    if (candidates.length > 1)
+        invalidDesignResourceHandoff("implementation_dependency_resolution_ambiguous", `${resolved}:${candidates.join(",")}`);
+    return candidates[0] ?? null;
+}
+export const validateDesignResourceWebDependencyClosure = validateDesignResourceImplementationDependencyClosure;

package/dist/lib/execution-target-capabilities.d.ts

@@ -1,2 +1,2 @@
-export declare const EXECUTION_TARGET_CAPABILITIES: readonly ["browser-runtime", "native-runtime", "desktop-runtime", "service-runtime", "process-runtime", "external-runtime", "cold-start", "production-root", "pointer-input", "keyboard-input", "touch-input", "viewport-control", "pixel-density-observation", "safe-area-observation", "motion-observation", "reduced-motion", "color-scheme-control", "text-scale-control", "assistive-technology", "screen-reader", "physical-device", "device-orientation", "sensor-input", "camera-input", "haptic-output", "thermal-observation", "power-mode-control", "persistent-storage", "network-boundary"];
+export declare const EXECUTION_TARGET_CAPABILITIES: readonly ["browser-runtime", "native-runtime", "desktop-runtime", "service-runtime", "process-runtime", "external-runtime", "cold-start", "production-root", "pointer-input", "keyboard-input", "touch-input", "viewport-control", "pixel-density-observation", "safe-area-observation", "motion-observation", "reduced-motion", "color-scheme-control", "text-scale-control", "localization-control", "rtl-control", "assistive-technology", "screen-reader", "physical-device", "device-orientation", "sensor-input", "camera-input", "haptic-output", "audio-output", "reduced-transparency", "increased-contrast", "bold-text-control", "button-shapes-control", "system-ui-observation", "ime-control", "permission-control", "network-state-control", "lifecycle-control", "window-state-control", "fold-state-control", "thermal-observation", "power-mode-control", "persistent-storage", "network-boundary"];
 export type ExecutionTargetCapabilityV2 = (typeof EXECUTION_TARGET_CAPABILITIES)[number];

package/dist/lib/execution-target-capabilities.js

@@ -17,6 +17,8 @@ export const EXECUTION_TARGET_CAPABILITIES = [
     "reduced-motion",
     "color-scheme-control",
     "text-scale-control",
+    "localization-control",
+    "rtl-control",
     "assistive-technology",
     "screen-reader",
     "physical-device",
@@ -24,6 +26,18 @@ export const EXECUTION_TARGET_CAPABILITIES = [
     "sensor-input",
     "camera-input",
     "haptic-output",
+    "audio-output",
+    "reduced-transparency",
+    "increased-contrast",
+    "bold-text-control",
+    "button-shapes-control",
+    "system-ui-observation",
+    "ime-control",
+    "permission-control",
+    "network-state-control",
+    "lifecycle-control",
+    "window-state-control",
+    "fold-state-control",
     "thermal-observation",
     "power-mode-control",
     "persistent-storage",

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

@@ -7,6 +7,7 @@ import { validateSemanticConformance } from "./long-task-conformance-policy.js";
 import { deliveryContractStructureDiagnostics, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
 import { validateRawExecutionObservationOwnership } from "./long-task-observation-ownership.js";
 import { validateLongTaskDesignResourceHandoffs } from "./long-task-design-resource-handoff.js";
+import { validateLongTaskSemanticFactClosure } from "./long-task-semantic-fact-closure.js";
 import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
 import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
 import { validateSourceContinuity } from "./long-task-source-continuity.js";
@@ -49,6 +50,9 @@ export async function validateContractForActivation(options) {
         return decision;
     });
     const context = await attempt(mode, diagnostics, () => captureContextGraphSnapshot(repository, contract.task.context_refs, contract.task.context_snapshot_mode));
+    const semanticFactClosure = sourceItems && context
+        ? await attempt(mode, diagnostics, () => validateLongTaskSemanticFactClosure(contract, repository, sourceItems, context.files))
+        : null;
     const workdirRelative = repoRelative(repository, workdir);
     const workspace = await attempt(mode, diagnostics, async () => {
         const manifest = await captureWorkspaceManifest(repository, workdir);
@@ -62,7 +66,7 @@ export async function validateContractForActivation(options) {
         const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
         if (!executionTarget)
             continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, []), null, check.key);
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], []), null, check.key);
         if (frozen)
             globalChecks.push(frozen);
     }
@@ -73,7 +77,7 @@ export async function validateContractForActivation(options) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key)), outcome.key, check.key);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? []), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }

package/dist/lib/long-task-applicability-shape.js

@@ -1,4 +1,4 @@
-import { array, key, literal, object, string, strings, } from "./long-task-shape-primitives.js";
+import { array, key, literal, object, semanticRef, string, strings, } from "./long-task-shape-primitives.js";
 const JOURNEY_ROLES = [
     "success",
     "degradation",
@@ -25,8 +25,8 @@ export function parseClaimApplicability(value, label) {
                 const dimensionLabel = `${itemLabel}.dimensions[${dimensionIndex}]`;
                 const entry = object(dimension, dimensionLabel, ["key", "value"]);
                 return {
-                    key: key(entry.key, `${dimensionLabel}.key`),
-                    value: key(entry.value, `${dimensionLabel}.value`),
+                    key: semanticRef(entry.key, `${dimensionLabel}.key`),
+                    value: semanticRef(entry.value, `${dimensionLabel}.value`),
                 };
             }),
             given_refs: parseKeyRefs(row.given_refs, `${itemLabel}.given_refs`),

package/dist/lib/long-task-authoring-authority-preview.js

@@ -31,6 +31,7 @@ export function authoringRevisionPreview(contract, sourceHashes, sourceItems, co
     const hashes = computeAuthorityHashes(contract);
     const previousDeclaredHashes = computeAuthorityHashes({
         schema_version: "long-task-delivery-v2",
+        semantic_fact_manifest: active.authority_snapshot.semantic_fact_manifest,
         task: active.authority_snapshot.task,
         source_claims: active.authority_snapshot.source_claims,
         stages: active.authority_snapshot.stages,

package/dist/lib/long-task-authority-policy.d.ts

@@ -60,6 +60,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         stage: "semantic_user_review";
         depends_on: "readiness_only";
         applicability: "semantic_user_review";
+        semantic_fact_bindings: "semantic_user_review";
         product: "semantic_user_review";
         technical: "semantic_user_review";
         acceptance: "proof_additive";

package/dist/lib/long-task-authority-policy.js

@@ -43,6 +43,7 @@ const OUTCOME_AUTHORITY_POLICY = {
     stage: "semantic_user_review",
     depends_on: "readiness_only",
     applicability: "semantic_user_review",
+    semantic_fact_bindings: "semantic_user_review",
     product: "semantic_user_review",
     technical: "semantic_user_review",
     acceptance: "proof_additive",

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

@@ -17,6 +17,7 @@ export function computeAuthorityHashes(contract) {
         source_authority_hash: hash({
             source_paths: contract.task.source_paths,
             source_claims: contract.source_claims,
+            semantic_fact_manifest: contract.semantic_fact_manifest,
         }),
         product_authority_hash: hash({
             goal: contract.task.goal,
@@ -31,6 +32,14 @@ export function computeAuthorityHashes(contract) {
                 key: outcome.key,
                 stage: outcome.stage,
                 applicability: outcome.applicability,
+                ...(outcome.semantic_fact_bindings
+                    ? {
+                        semantic_fact_bindings: {
+                            manifest_ref: outcome.semantic_fact_bindings.manifest_ref,
+                            facts: outcome.semantic_fact_bindings.facts,
+                        },
+                    }
+                    : {}),
                 product: outcome.product,
             })),
         }),
@@ -40,6 +49,9 @@ export function computeAuthorityHashes(contract) {
             global_counterfactual_controls: contract.global.acceptance.counterfactual_controls,
             outcomes: contract.outcomes.map((outcome) => ({
                 key: outcome.key,
+                ...(outcome.semantic_fact_bindings
+                    ? { semantic_fact_proofs: outcome.semantic_fact_bindings.proofs }
+                    : {}),
                 checks: outcome.acceptance.checks.map(acceptanceCheck),
                 population: outcome.acceptance.population,
                 counterfactual_controls: outcome.acceptance.counterfactual_controls,
@@ -61,6 +73,7 @@ export function outcomeAuthorityHash(outcome) {
     return hash({
         stage: outcome.stage,
         applicability: outcome.applicability,
+        semantic_fact_bindings: outcome.semantic_fact_bindings,
         product: outcome.product,
         acceptance: {
             checks: outcome.acceptance.checks.map(acceptanceCheck),