project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/design-resource-symbolic-applicability-policy.js

@@ -0,0 +1,79 @@
+import { DESIGN_RESOURCE_STANDARD_PROPERTIES } from "./design-resource-fact-manifest-catalog.js";
+import { compareText } from "./design-resource-symbolic-validation-support.js";
+export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_POLICY_VERSION = "package-subject-capability-algebra-v1";
+const BASE_VISUAL_PROPERTIES = ["geometry.width", "color.background"];
+const SUBJECT_FAMILIES = {
+    surface: [],
+    flow: ["navigation"],
+    region: [],
+    overlay: ["interaction", "accessibility"],
+    system_ui: ["system", "accessibility"],
+    component_family: [],
+    component_instance: [],
+    control: ["interaction", "accessibility"],
+    anatomy_part: [],
+    slot: [],
+    primitive: [],
+    text: ["typography", "content"],
+    icon: ["icon", "asset", "accessibility"],
+    media: ["media", "asset", "accessibility"],
+    asset: ["asset"],
+    relation: ["relation"],
+};
+const CENSUS_FAMILIES = {
+    asset_reference: ["asset"],
+    relation: ["relation"],
+    dynamic_population: ["content"],
+    interaction_phase: ["interaction"],
+};
+const propertyRefsByFamily = new Map();
+for (const property of DESIGN_RESOURCE_STANDARD_PROPERTIES) {
+    const values = propertyRefsByFamily.get(property.family) ?? [];
+    values.push(property.key);
+    propertyRefsByFamily.set(property.family, values);
+}
+export function symbolicApplicabilitySubjectPolicyRef(kind) {
+    return `package-policy.subject-kind.${kind}.v1`;
+}
+export function symbolicApplicabilityCensusPolicyRef(kind) {
+    return `package-policy.census-kind.${kind.replaceAll("_", "-")}.v1`;
+}
+export const SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF = "package-policy.subject-population.v1";
+export function deriveRequiredSymbolicStandardApplicability(subject, census) {
+    const properties = new Set();
+    const policyBasis = new Set();
+    for (const propertyRef of BASE_VISUAL_PROPERTIES)
+        properties.add(propertyRef);
+    addFamilies(properties, SUBJECT_FAMILIES[subject.kind] ?? []);
+    policyBasis.add(symbolicApplicabilitySubjectPolicyRef(subject.kind));
+    for (const censusRef of subject.census_refs) {
+        const kind = census.get(censusRef)?.kind;
+        if (!kind)
+            continue;
+        const families = CENSUS_FAMILIES[kind] ?? [];
+        if (!families.length)
+            continue;
+        addFamilies(properties, families);
+        policyBasis.add(symbolicApplicabilityCensusPolicyRef(kind));
+    }
+    if (subject.population_ref !== null) {
+        addFamilies(properties, ["content"]);
+        policyBasis.add(SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF);
+    }
+    return {
+        property_refs: [...properties].sort(compareText),
+        policy_basis_refs: [...policyBasis].sort(compareText),
+    };
+}
+export function isKnownSymbolicApplicabilityPolicyRef(value) {
+    if (value === SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF)
+        return true;
+    if (Object.keys(SUBJECT_FAMILIES).some((kind) => value === symbolicApplicabilitySubjectPolicyRef(kind)))
+        return true;
+    return Object.keys(CENSUS_FAMILIES).some((kind) => value === symbolicApplicabilityCensusPolicyRef(kind));
+}
+function addFamilies(properties, families) {
+    for (const family of families)
+        for (const propertyRef of propertyRefsByFamily.get(family) ?? [])
+            properties.add(propertyRef);
+}

package/dist/lib/design-resource-symbolic-applicability-profiles.d.ts

@@ -0,0 +1,8 @@
+export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG: "package-subject-property-applicability-v1";
+export interface DesignResourceSymbolicApplicabilityProfileV1 {
+    key: string;
+    property_refs: readonly string[];
+}
+export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILES: readonly DesignResourceSymbolicApplicabilityProfileV1[];
+export declare function symbolicPropertyProfileKey(propertyRef: string): string;
+export declare function resolveSymbolicApplicabilityProfiles(profileRefs: readonly string[], label: string): Set<string>;

package/dist/lib/design-resource-symbolic-applicability-profiles.js

@@ -0,0 +1,55 @@
+import { DESIGN_RESOURCE_STANDARD_PROPERTIES, DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS, } from "./design-resource-fact-manifest-catalog.js";
+import { DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, DESIGN_RESOURCE_PROPERTY_FAMILIES, } from "./design-resource-fact-manifest-types.js";
+import { compareText, invalid, } from "./design-resource-symbolic-validation-support.js";
+export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG = "package-subject-property-applicability-v1";
+const profiles = buildProfiles();
+export const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILES = Object.freeze(profiles);
+const profileByKey = new Map(profiles.map((profile) => [profile.key, profile]));
+export function symbolicPropertyProfileKey(propertyRef) {
+    return `profile.property.${propertyRef}`;
+}
+export function resolveSymbolicApplicabilityProfiles(profileRefs, label) {
+    const propertyRefs = new Set();
+    for (const profileRef of profileRefs) {
+        const profile = profileByKey.get(profileRef);
+        if (!profile)
+            invalid("v2_applicability_profile_unknown", `${label}:${profileRef}`);
+        for (const propertyRef of profile.property_refs)
+            propertyRefs.add(propertyRef);
+    }
+    return propertyRefs;
+}
+function buildProfiles() {
+    const result = [
+        {
+            key: "profile.all-standard",
+            property_refs: [...DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS],
+        },
+    ];
+    for (const property of DESIGN_RESOURCE_STANDARD_PROPERTIES)
+        result.push({
+            key: symbolicPropertyProfileKey(property.key),
+            property_refs: [property.key],
+        });
+    for (const family of DESIGN_RESOURCE_PROPERTY_FAMILIES)
+        result.push({
+            key: `profile.family.${family}`,
+            property_refs: DESIGN_RESOURCE_STANDARD_PROPERTIES.filter((property) => property.family === family).map((property) => property.key),
+        });
+    for (const capability of DESIGN_RESOURCE_INSPECTOR_CAPABILITIES)
+        result.push({
+            key: `profile.capability.${capability}`,
+            property_refs: DESIGN_RESOURCE_STANDARD_PROPERTIES.filter((property) => property.inspector_capability_refs.includes(capability)).map((property) => property.key),
+        });
+    result.sort((left, right) => compareText(left.key, right.key));
+    if (new Set(result.map((profile) => profile.key)).size !== result.length)
+        invalid("v2_applicability_profile_catalog_duplicate", "");
+    const covered = new Set(result.flatMap((profile) => profile.property_refs));
+    if (covered.size !== DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS.length ||
+        DESIGN_RESOURCE_STANDARD_PROPERTY_KEYS.some((key) => !covered.has(key)))
+        invalid("v2_applicability_profile_catalog_incomplete", "");
+    return result.map((profile) => Object.freeze({
+        ...profile,
+        property_refs: Object.freeze([...profile.property_refs].sort(compareText)),
+    }));
+}

package/dist/lib/design-resource-symbolic-applicability-shape.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceSymbolicStructuralApplicabilityV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function parseSymbolicStructuralApplicability(value: unknown, label: string): DesignResourceSymbolicStructuralApplicabilityV2;

package/dist/lib/design-resource-symbolic-applicability-shape.js

@@ -0,0 +1,76 @@
+import { sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, literal, object, string, } from "./long-task-shape-primitives.js";
+export function parseSymbolicStructuralApplicability(value, label) {
+    const root = object(value, label, [
+        "profile_catalog",
+        "subject_profile_bindings",
+        "inspector_custom_property_closure",
+        "instance_exceptions",
+    ]);
+    return {
+        profile_catalog: literal(root.profile_catalog, ["package-subject-property-applicability-v1"], `${label}.profile_catalog`),
+        subject_profile_bindings: array(root.subject_profile_bindings, `${label}.subject_profile_bindings`).map((item, index) => parseProfileBinding(item, `${label}.subject_profile_bindings[${index}]`)),
+        inspector_custom_property_closure: array(root.inspector_custom_property_closure, `${label}.inspector_custom_property_closure`).map((item, index) => parseCustomPropertyClosure(item, `${label}.inspector_custom_property_closure[${index}]`)),
+        instance_exceptions: array(root.instance_exceptions, `${label}.instance_exceptions`).map((item, index) => parseInstanceException(item, `${label}.instance_exceptions[${index}]`)),
+    };
+}
+function parseProfileBinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "subject_refs",
+        "profile_refs",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        subject_refs: stableKeys(row.subject_refs, `${label}.subject_refs`),
+        profile_refs: stableKeys(row.profile_refs, `${label}.profile_refs`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}
+function parseCustomPropertyClosure(value, label) {
+    const row = object(value, label, [
+        "property_ref",
+        "applicable_subject_refs",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        property_ref: stableKey(row.property_ref, `${label}.property_ref`),
+        applicable_subject_refs: stableKeys(row.applicable_subject_refs, `${label}.applicable_subject_refs`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}
+function parseInstanceException(value, label) {
+    const row = object(value, label, [
+        "key",
+        "subject_ref",
+        "property_ref",
+        "disposition",
+        "census_refs",
+        "source_item_refs",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        subject_ref: stableKey(row.subject_ref, `${label}.subject_ref`),
+        property_ref: stableKey(row.property_ref, `${label}.property_ref`),
+        disposition: literal(row.disposition, ["applicable", "not_applicable"], `${label}.disposition`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}

package/dist/lib/design-resource-symbolic-applicability-validation.d.ts

@@ -0,0 +1,7 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export interface SymbolicApplicabilityIndex {
+    mode: "legacy_physical_partitions" | "package_profiles";
+    isApplicable(subjectRef: string, propertyRef: string): boolean;
+}
+export declare function buildSymbolicApplicabilityIndex(manifest: DesignResourceObservableRuleManifestV2, indexes: SymbolicManifestIndexes): SymbolicApplicabilityIndex;

package/dist/lib/design-resource-symbolic-applicability-validation.js

@@ -0,0 +1,128 @@
+import { DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG, resolveSymbolicApplicabilityProfiles, } from "./design-resource-symbolic-applicability-profiles.js";
+import { deriveRequiredSymbolicStandardApplicability } from "./design-resource-symbolic-applicability-policy.js";
+import { validateSymbolicApplicabilityAuthorityRefs as validateAuthorityRefs } from "./design-resource-symbolic-applicability-authority.js";
+import { assertSameSet, invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+export function buildSymbolicApplicabilityIndex(manifest, indexes) {
+    const compact = manifest.structural_applicability;
+    if (!compact)
+        return {
+            mode: "legacy_physical_partitions",
+            isApplicable: () => true,
+        };
+    if (compact.profile_catalog !==
+        DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_PROFILE_CATALOG)
+        invalid("v2_applicability_profile_catalog_unknown", compact.profile_catalog);
+    const artifactRefs = new Set(manifest.noninterference_certificates.flatMap((certificate) => [
+        certificate.source_noninterference_proof,
+        certificate.production_noninterference_proof,
+    ]
+        .filter((proof) => proof != null)
+        .map((proof) => proof.artifact_resource_ref)));
+    const { effective, expected } = validateProfileBindings(manifest, indexes, artifactRefs);
+    validateCustomPropertyClosure(manifest, indexes, effective, expected, artifactRefs);
+    validateInstanceExceptions(manifest, indexes, effective, expected, artifactRefs);
+    for (const subjectRef of indexes.subjects.keys())
+        assertSameSet([...(effective.get(subjectRef) ?? [])], [...(expected.get(subjectRef) ?? [])], "v2_applicability_package_derived_set_mismatch", subjectRef);
+    return {
+        mode: "package_profiles",
+        isApplicable(subjectRef, propertyRef) {
+            const properties = effective.get(subjectRef);
+            if (!properties)
+                invalid("v2_applicability_subject_unknown", subjectRef);
+            if (!indexes.properties.has(propertyRef))
+                invalid("v2_applicability_property_unknown", propertyRef);
+            return properties.has(propertyRef);
+        },
+    };
+}
+function validateProfileBindings(manifest, indexes, artifactRefs) {
+    const bindings = manifest.structural_applicability.subject_profile_bindings;
+    unique(bindings.map((binding) => binding.key), "v2_applicability_profile_binding_key_duplicate");
+    const boundSubjects = bindings.flatMap((binding) => binding.subject_refs);
+    unique(boundSubjects, "v2_applicability_subject_profile_ambiguous");
+    assertSameSet(boundSubjects, [...indexes.subjects.keys()], "v2_applicability_subject_profile_set_mismatch", manifest.target_key);
+    const effective = new Map();
+    const expected = new Map();
+    for (const binding of bindings) {
+        if (!binding.subject_refs.length || !binding.profile_refs.length)
+            invalid("v2_applicability_profile_binding_empty", binding.key);
+        validateAuthorityRefs(binding, indexes, artifactRefs, binding.key);
+        unique(binding.profile_refs, `v2_applicability_profile_ref_duplicate:${binding.key}`);
+        const properties = resolveSymbolicApplicabilityProfiles(binding.profile_refs, binding.key);
+        const subjectCensusRefs = binding.subject_refs.flatMap((subjectRef) => {
+            const subject = indexes.subjects.get(subjectRef);
+            if (!subject)
+                invalid("v2_applicability_profile_subject_unknown", subjectRef);
+            return subject.census_refs;
+        });
+        assertSameSet(binding.census_refs, subjectCensusRefs, "v2_applicability_subject_census_set_mismatch", binding.key);
+        for (const subjectRef of binding.subject_refs) {
+            const subject = indexes.subjects.get(subjectRef);
+            if (!subject)
+                invalid("v2_applicability_profile_subject_unknown", subjectRef);
+            const derived = deriveRequiredSymbolicStandardApplicability(subject, indexes.census);
+            for (const basisRef of derived.policy_basis_refs)
+                if (!binding.basis_refs.includes(basisRef))
+                    invalid("v2_applicability_package_policy_basis_missing", `${binding.key}:${subjectRef}:${basisRef}`);
+            effective.set(subjectRef, new Set(properties));
+            expected.set(subjectRef, new Set(derived.property_refs));
+        }
+    }
+    return { effective, expected };
+}
+function validateCustomPropertyClosure(manifest, indexes, effective, expected, artifactRefs) {
+    const rows = manifest.structural_applicability.inspector_custom_property_closure;
+    unique(rows.map((row) => row.property_ref), "v2_custom_property_closure_duplicate");
+    const customProperties = manifest.properties.filter((property) => !property.standard);
+    assertSameSet(rows.map((row) => row.property_ref), customProperties.map((property) => property.key), "v2_custom_property_closure_set_mismatch", manifest.target_key);
+    for (const row of rows) {
+        const property = indexes.properties.get(row.property_ref);
+        if (!property || property.standard)
+            invalid("v2_custom_property_closure_property_unknown", row.property_ref);
+        validateAuthorityRefs(row, indexes, artifactRefs, row.property_ref);
+        requireKnownRefs(row.applicable_subject_refs, indexes.subjects, "v2_custom_property_subject_unknown");
+        unique(row.applicable_subject_refs, `v2_custom_property_subject_duplicate:${row.property_ref}`);
+        assertSameSet(row.census_refs, property.census_refs, "v2_custom_property_census_set_mismatch", row.property_ref);
+        for (const censusRef of row.census_refs) {
+            const census = indexes.census.get(censusRef);
+            if (census?.kind !== "custom_property" ||
+                census.disposition !== "covered")
+                invalid("v2_custom_property_census_authority_invalid", `${row.property_ref}:${censusRef}`);
+        }
+        for (const subjectRef of row.applicable_subject_refs)
+            for (const index of [effective, expected])
+                index.get(subjectRef).add(row.property_ref);
+    }
+    assertSameSet(rows.flatMap((row) => row.census_refs), manifest.inspector.census
+        .filter((row) => row.kind === "custom_property")
+        .map((row) => row.key), "v2_custom_property_census_closure_mismatch", manifest.target_key);
+}
+function validateInstanceExceptions(manifest, indexes, effective, expected, artifactRefs) {
+    const exceptions = manifest.structural_applicability.instance_exceptions;
+    unique(exceptions.map((item) => item.key), "v2_applicability_exception_key_duplicate");
+    const tupleKeys = exceptions.map((item) => `${item.subject_ref}\u0000${item.property_ref}`);
+    unique(tupleKeys, "v2_applicability_exception_tuple_duplicate");
+    for (const exception of exceptions) {
+        const subject = indexes.subjects.get(exception.subject_ref);
+        if (!subject)
+            invalid("v2_applicability_exception_subject_unknown", exception.key);
+        const property = indexes.properties.get(exception.property_ref);
+        if (!property)
+            invalid("v2_applicability_exception_property_unknown", exception.key);
+        validateAuthorityRefs(exception, indexes, artifactRefs, exception.key);
+        assertSameSet(exception.census_refs, [...subject.census_refs, ...property.census_refs], "v2_applicability_exception_census_set_mismatch", exception.key);
+        const properties = effective.get(exception.subject_ref);
+        const requestedApplicability = exception.disposition === "applicable";
+        if (properties.has(exception.property_ref) === requestedApplicability)
+            invalid("v2_applicability_exception_noop", exception.key);
+        if (exception.disposition === "applicable")
+            properties.add(exception.property_ref);
+        else
+            properties.delete(exception.property_ref);
+        const expectedProperties = expected.get(exception.subject_ref);
+        if (exception.disposition === "applicable")
+            expectedProperties.add(exception.property_ref);
+        else
+            expectedProperties.delete(exception.property_ref);
+    }
+}

package/dist/lib/design-resource-symbolic-compilation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function createDesignResourceSymbolicCompilationSession(manifest: DesignResourceObservableRuleManifestV2): import("./symbolic-denotation-engine.js").SymbolicDenotationCompilationSession;
+export type DesignResourceSymbolicCompilationSession = ReturnType<typeof createDesignResourceSymbolicCompilationSession>;

package/dist/lib/design-resource-symbolic-compilation.js

@@ -0,0 +1,13 @@
+import { createSymbolicDenotationCompilationSession } from "./symbolic-denotation-engine.js";
+export function createDesignResourceSymbolicCompilationSession(manifest) {
+    return createSymbolicDenotationCompilationSession(manifest.axis_domains, [
+        manifest.reachable_region,
+        ...manifest.fact_rules.map((rule) => rule.region),
+        ...manifest.disposition_regions.map((row) => row.region),
+        ...manifest.populations.flatMap((population) => population.exclusions.map((exclusion) => exclusion.region)),
+        ...manifest.noninterference_certificates.flatMap((certificate) => [certificate.production_noninterference_proof].flatMap((proof) => proof?.equivalence_cases.flatMap((item) => [
+            item.side_predicate,
+            item.axis_erased_predicate,
+        ]) ?? [])),
+    ]);
+}

package/dist/lib/design-resource-symbolic-denotation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicExtensionalPointV1, SymbolicPointDenotationV1 } from "./symbolic-denotation-types.js";
+export declare function denoteDesignResourceSymbolicPoint(preflight: DesignResourceHandoffPreflightV2, point: SymbolicExtensionalPointV1): SymbolicPointDenotationV1;

package/dist/lib/design-resource-symbolic-denotation.js

@@ -0,0 +1,167 @@
+import { buildSymbolicApplicabilityIndex } from "./design-resource-symbolic-applicability-validation.js";
+import { createDesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import { buildSymbolicManifestIndexes, symbolicSemanticTupleKey, } from "./design-resource-symbolic-indexes.js";
+import { evaluateCanonicalSymbolicDenotation } from "./symbolic-denotation-engine.js";
+const queryIndexCache = new WeakMap();
+export function denoteDesignResourceSymbolicPoint(preflight, point) {
+    const manifest = preflight.manifest;
+    const assignment = {
+        ...point.condition_assignment,
+        ...point.variation_assignment,
+    };
+    validateCompleteAssignment(manifest.axis_domains, assignment);
+    const query = queryIndex(preflight);
+    validatePointTupleAuthority(preflight, query.indexes, point);
+    const reachable = query.reachable;
+    if (!evaluateCanonicalSymbolicDenotation(reachable.canonical_dag, assignment))
+        invalid("extensional_point_unreachable", pointIdentity(point));
+    if (!query.applicability.isApplicable(point.subject_or_relation_ref, point.property_ref))
+        return {
+            disposition: "not_applicable",
+            expected_semantics: null,
+            proof_obligations: [],
+        };
+    const tupleKey = symbolicSemanticTupleKey(point);
+    const rules = (query.rulesByTuple.get(tupleKey) ?? []).filter((projection) => evaluateCanonicalSymbolicDenotation(projection.compiled_region.canonical_dag, assignment));
+    const dispositions = (query.dispositionsByTuple.get(tupleKey) ?? []).filter((projection) => evaluateCanonicalSymbolicDenotation(projection.compiled.canonical_dag, assignment));
+    if (rules.length + dispositions.length !== 1)
+        invalid("extensional_point_effective_region_invalid", `${pointIdentity(point)}:rules=${rules.length}:dispositions=${dispositions.length}`);
+    if (dispositions.length)
+        return {
+            disposition: dispositions[0].row.disposition,
+            expected_semantics: null,
+            proof_obligations: [],
+        };
+    const rule = rules[0].rule;
+    const obligations = rule.semantic_obligation_refs
+        .map((ref) => query.indexes.obligations.get(ref))
+        .map((obligation) => {
+        if (!obligation)
+            invalid("semantic_obligation_unknown", rule.key);
+        const oracle = query.indexes.oracles.get(obligation.oracle_ref);
+        const environment = query.indexes.environments.get(obligation.environment_ref);
+        if (!oracle || !environment)
+            invalid("semantic_obligation_authority_unknown", obligation.key);
+        return {
+            method: obligation.method,
+            proof_surface: obligation.proof_surface,
+            observation_boundary: obligation.observation_boundary,
+            comparison: structuredClone(obligation.comparison),
+            oracle: structuredClone(oracle),
+            environment: structuredClone(environment),
+            protected_value_policy: obligation.protected_value_policy,
+            completion_effect: obligation.completion_effect,
+        };
+    })
+        .sort((left, right) => compareText(left.method, right.method));
+    return {
+        disposition: "specified",
+        expected_semantics: {
+            value_type: rule.value_kind,
+            expected: structuredClone(rule.expected),
+            provenance_ref: rule.provenance_ref,
+            sensitivity: rule.observation_sensitivity,
+            population_ref: rule.population_ref,
+            quantifier: structuredClone(rule.quantifier),
+            lineage: structuredClone(rule.lineage),
+        },
+        proof_obligations: obligations,
+    };
+}
+function validatePointTupleAuthority(preflight, indexes, point) {
+    const manifest = preflight.manifest;
+    const subject = indexes.subjects.get(point.subject_or_relation_ref);
+    if (!subject || point.target_ref !== manifest.target_key)
+        invalid("extensional_point_subject_target_unknown", pointIdentity(point));
+    if (!indexes.properties.has(point.property_ref))
+        invalid("extensional_point_property_unknown", point.property_ref);
+    const expectedQuantifier = subject.population_ref
+        ? indexes.populations.get(subject.population_ref)?.quantifier
+        : { kind: "one", minimum: 1, maximum: 1 };
+    if (point.population_ref !== subject.population_ref ||
+        canonicalJson(point.quantifier) !== canonicalJson(expectedQuantifier))
+        invalid("extensional_point_population_quantifier_mismatch", pointIdentity(point));
+}
+function queryIndex(preflight) {
+    const cached = queryIndexCache.get(preflight);
+    if (cached)
+        return cached;
+    const built = buildQueryIndex(preflight);
+    queryIndexCache.set(preflight, built);
+    return built;
+}
+function buildQueryIndex(preflight) {
+    const indexes = buildSymbolicManifestIndexes(preflight.manifest, preflight);
+    const applicability = buildSymbolicApplicabilityIndex(preflight.manifest, indexes);
+    const compilation = createDesignResourceSymbolicCompilationSession(preflight.manifest);
+    const rulesByTuple = new Map();
+    for (const projection of preflight.rule_projections) {
+        const key = symbolicSemanticTupleKey(projection.rule);
+        const values = rulesByTuple.get(key);
+        if (values)
+            values.push(projection);
+        else
+            rulesByTuple.set(key, [projection]);
+    }
+    const dispositionsByTuple = new Map();
+    for (const row of preflight.manifest.disposition_regions) {
+        const key = symbolicSemanticTupleKey(row);
+        const projection = { row, compiled: compilation.compile(row.region) };
+        const values = dispositionsByTuple.get(key);
+        if (values)
+            values.push(projection);
+        else
+            dispositionsByTuple.set(key, [projection]);
+    }
+    return {
+        indexes,
+        applicability,
+        rulesByTuple,
+        dispositionsByTuple,
+        reachable: compilation.compile(preflight.manifest.reachable_region),
+    };
+}
+function validateCompleteAssignment(domains, assignment) {
+    const actual = Object.keys(assignment).sort(compareText);
+    const expected = domains.map((domain) => domain.key).sort(compareText);
+    if (actual.length !== expected.length ||
+        actual.some((key, index) => key !== expected[index]))
+        invalid("extensional_assignment_axis_set_mismatch", `${actual.join(",")}:${expected.join(",")}`);
+    for (const domain of domains) {
+        const value = assignment[domain.key];
+        if (domain.kind === "enum"
+            ? typeof value !== "string" || !domain.values.includes(value)
+            : typeof value !== "number" ||
+                !Number.isSafeInteger(value) ||
+                value < domain.minimum ||
+                value > domain.maximum)
+            invalid("extensional_assignment_value_outside_domain", `${domain.key}:${String(value)}`);
+    }
+}
+function pointIdentity(point) {
+    return [
+        point.subject_or_relation_ref,
+        point.target_ref,
+        point.property_ref,
+        point.population_ref ?? "none",
+        canonicalJson(point.quantifier),
+        canonicalJson(point.condition_assignment),
+        canonicalJson(point.variation_assignment),
+    ].join(":");
+}
+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]) => compareText(left, right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function invalid(code, detail) {
+    throw new Error(`design_resource_symbolic_denotation_invalid:${code}:${detail}`);
+}

package/dist/lib/design-resource-symbolic-disposition-validation.d.ts

@@ -0,0 +1,4 @@
+import type { DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateSymbolicDispositions(manifest: DesignResourceObservableRuleManifestV2, targetKey: string, indexes: SymbolicManifestIndexes, compilation: DesignResourceSymbolicCompilationSession): void;

package/dist/lib/design-resource-symbolic-disposition-validation.js

@@ -0,0 +1,28 @@
+import { assertNoUnprovedOmittedAxes } from "./design-resource-symbolic-safety-validation.js";
+import { validateSymbolicPopulationAndQuantifier, validateSymbolicRegionWithinReachable, } from "./design-resource-symbolic-region-validation.js";
+import { invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicDispositions(manifest, targetKey, indexes, compilation) {
+    for (const disposition of manifest.disposition_regions) {
+        const subject = indexes.subjects.get(disposition.subject_or_relation_ref);
+        if (!subject)
+            invalid("v2_disposition_subject_unknown", disposition.key);
+        if (!indexes.properties.has(disposition.property_ref))
+            invalid("v2_disposition_property_unknown", disposition.key);
+        if (disposition.target_ref !== targetKey)
+            invalid("v2_disposition_target_mismatch", disposition.key);
+        validateSymbolicPopulationAndQuantifier(disposition, subject.population_ref, indexes.populations);
+        if (!disposition.basis_refs.length || !disposition.source_item_refs.length)
+            invalid("v2_disposition_basis_source_required", disposition.key);
+        unique(disposition.census_refs, `v2_disposition_census_duplicate:${disposition.key}`);
+        unique(disposition.source_item_refs, `v2_disposition_source_item_duplicate:${disposition.key}`);
+        unique(disposition.basis_refs, `v2_disposition_basis_duplicate:${disposition.key}`);
+        requireKnownRefs(disposition.census_refs, indexes.census, "v2_disposition_census_unknown");
+        requireKnownRefs(disposition.source_item_refs, indexes.sourceItems, "v2_disposition_source_item_unknown");
+        validateSymbolicRegionWithinReachable(disposition.region, manifest.reachable_region, disposition.key, compilation);
+        assertNoUnprovedOmittedAxes(compilation.compile(disposition.region), disposition.key);
+        if (disposition.disposition === "decision_required" ||
+            disposition.disposition === "unavailable" ||
+            disposition.disposition === "blocking")
+            invalid("v2_unresolved_disposition", `${disposition.key}:${disposition.disposition}`);
+    }
+}

package/dist/lib/design-resource-symbolic-fact-policy.d.ts

@@ -0,0 +1,12 @@
+export declare const DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY: {
+    readonly symbolic_denotation_efficiency_delivery: true;
+    readonly control_relations_unchanged: true;
+    readonly forbidden_symbolic_shortcuts_absent: true;
+    readonly symbolic_inventory_is_not_completion: true;
+    readonly v1_capacity: {
+        readonly embedded_handoff_max_bytes: 8388608;
+        readonly canonical_manifest_max_bytes: 33554432;
+        readonly expected_fact_cells_max: 16384;
+        readonly capacity_header_prefix_max_bytes: 65536;
+    };
+};

package/dist/lib/design-resource-symbolic-fact-policy.js

@@ -0,0 +1,12 @@
+export const DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY = {
+    symbolic_denotation_efficiency_delivery: true,
+    control_relations_unchanged: true,
+    forbidden_symbolic_shortcuts_absent: true,
+    symbolic_inventory_is_not_completion: true,
+    v1_capacity: {
+        embedded_handoff_max_bytes: 8_388_608,
+        canonical_manifest_max_bytes: 33_554_432,
+        expected_fact_cells_max: 16_384,
+        capacity_header_prefix_max_bytes: 65_536,
+    },
+};

package/dist/lib/design-resource-symbolic-fact-shape.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+export { parseDesignResourceObservableRuleManifestJson, parseDesignResourceObservableRuleManifestShape, } from "./design-resource-symbolic-manifest-shape.js";
+export declare function parseDesignResourceSymbolicHandoffShape(value: unknown): DesignResourceHandoffV2;