project-tiny-context-harness 0.8.11 → 0.8.13

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

@@ -0,0 +1,10 @@
+import type { DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicHandoffTargetV2 } from "./design-resource-symbolic-fact-types.js";
+type Rule = DesignResourceObservableRuleManifestV2["fact_rules"][number];
+type Obligation = DesignResourceObservableRuleManifestV2["semantic_proof_obligations"][number];
+type Oracle = DesignResourceObservableRuleManifestV2["oracles"][number];
+type Environment = DesignResourceObservableRuleManifestV2["environments"][number];
+export declare function validateSymbolicProofAuthorities(manifest: DesignResourceObservableRuleManifestV2, target: DesignResourceSymbolicHandoffTargetV2, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateSymbolicObligationPolicy(obligation: Obligation, rule: Rule, property: DesignResourcePropertyDefinitionV1, oracle: Oracle, environment: Environment, target: DesignResourceSymbolicHandoffTargetV2, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export {};

package/dist/lib/design-resource-symbolic-proof-authority-validation.js

@@ -0,0 +1,68 @@
+import { designFactComparatorSupportsMethod, designFactMethodIsCompatible, designFactOracleSupportsMethod, } from "./design-resource-fact-policy.js";
+import { validateDesignResourceLocatedDigest } from "./design-resource-fact-locator-validation.js";
+import { invalid, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicProofAuthorities(manifest, target, resources, contents) {
+    for (const oracle of manifest.oracles) {
+        if (!oracle.capability_refs.length)
+            invalid("v2_oracle_capabilities_required", oracle.key);
+        unique(oracle.capability_refs, `v2_oracle_capability_duplicate:${oracle.key}`);
+        if (oracle.trust === "frozen_executable" && oracle.sha256 === null)
+            invalid("v2_oracle_digest_required", oracle.key);
+        if (oracle.trust === "named_external_tcb" && oracle.sha256 !== null)
+            invalid("v2_external_oracle_digest_forbidden", oracle.key);
+    }
+    for (const environment of manifest.environments) {
+        validateDesignResourceLocatedDigest(environment.definition, resources, contents, `v2.environment.${environment.key}`);
+        requireTargetResource(target, environment.definition.locator.resource_ref, "v2_environment_resource_outside_target", environment.key);
+    }
+}
+export function validateSymbolicObligationPolicy(obligation, rule, property, oracle, environment, target, resources, contents) {
+    if (!designFactMethodIsCompatible(property.dimension, obligation.method))
+        invalid("v2_proof_method_incompatible", `${obligation.key}:${property.dimension}:${obligation.method}`);
+    if (!designFactComparatorSupportsMethod(obligation.method, obligation.comparison.comparator))
+        invalid("v2_proof_comparator_method_incompatible", `${obligation.key}:${obligation.method}:${obligation.comparison.comparator}`);
+    if (!designFactOracleSupportsMethod(obligation.method, oracle.capability_refs))
+        invalid("v2_proof_oracle_capability_missing", `${obligation.key}:${oracle.key}:${obligation.method}`);
+    validateComparison(obligation, target, resources, contents);
+    requireTargetResource(target, environment.definition.locator.resource_ref, "v2_proof_environment_outside_target", obligation.key);
+    validateProtectedValuePolicy(rule, obligation);
+    if (obligation.proof_surface === "proxy_only")
+        invalid("v2_obligation_proxy_only_forbidden", obligation.key);
+    if (!obligation.proof_surface.trim() ||
+        !obligation.observation_boundary.trim() ||
+        obligation.completion_effect !== "required_for_rule_method_region")
+        invalid("v2_obligation_proof_meaning_incomplete", obligation.key);
+}
+function validateComparison(obligation, target, resources, contents) {
+    const { comparison } = obligation;
+    if (comparison.mode === "exact" &&
+        (comparison.tolerance !== null || comparison.mask !== null))
+        invalid("v2_exact_proof_tolerance_forbidden", obligation.key);
+    if (comparison.mode === "tolerance" && comparison.tolerance === null)
+        invalid("v2_tolerance_proof_tolerance_required", obligation.key);
+    if (comparison.mask !== null &&
+        comparison.comparator !== "pixel_diff" &&
+        !comparison.comparator.startsWith("custom."))
+        invalid("v2_proof_mask_comparator_incompatible", `${obligation.key}:${comparison.comparator}`);
+    for (const [name, located] of [
+        ["parameters", comparison.parameters],
+        ["tolerance", comparison.tolerance],
+        ["mask", comparison.mask],
+    ]) {
+        if (!located)
+            continue;
+        validateDesignResourceLocatedDigest(located, resources, contents, `v2.obligation.${obligation.key}.${name}`);
+        requireTargetResource(target, located.locator.resource_ref, "v2_proof_resource_outside_target", obligation.key);
+    }
+}
+function validateProtectedValuePolicy(rule, obligation) {
+    const plain = obligation.protected_value_policy === "plain_exact_observation";
+    if ((rule.observation_sensitivity === "plain" && !plain) ||
+        (rule.observation_sensitivity === "protected" &&
+            (plain || !obligation.protected_value_policy.trim())))
+        invalid("v2_protected_value_policy_mismatch", obligation.key);
+}
+function requireTargetResource(target, resourceRef, code, detail) {
+    if (!target.resource_refs.includes(resourceRef))
+        invalid(code, `${detail}:${resourceRef}`);
+}

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

@@ -0,0 +1,10 @@
+import type { DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import type { DesignResourceHandoffPreflightV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicHandoffTargetV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateSymbolicObligations(manifest: DesignResourceObservableRuleManifestV2, projections: DesignResourceHandoffPreflightV2["rule_projections"], properties: Map<string, DesignResourcePropertyDefinitionV1>, oracles: Map<string, DesignResourceObservableRuleManifestV2["oracles"][number]>, environments: Map<string, DesignResourceObservableRuleManifestV2["environments"][number]>, target: DesignResourceSymbolicHandoffTargetV2, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateSymbolicCertificates(manifest: DesignResourceObservableRuleManifestV2, projections: DesignResourceHandoffPreflightV2["rule_projections"], indexes: SymbolicManifestIndexes, compilation: DesignResourceSymbolicCompilationSession, target: DesignResourceSymbolicHandoffTargetV2, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): {
+    coveredOmittedAxes: number;
+    coveredDependencyEdges: number;
+};

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

@@ -0,0 +1,89 @@
+import { validateSymbolicObligationPolicy, validateSymbolicProofAuthorities, } from "./design-resource-symbolic-proof-authority-validation.js";
+import { validateTrustedSymbolicNoninterference } from "./design-resource-symbolic-noninterference-validation.js";
+import { assertCanonicalSet, assertSameSet, compareText, designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicObligationKey, invalid, omitKey, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicObligations(manifest, projections, properties, oracles, environments, target, resources, contents) {
+    validateSymbolicProofAuthorities(manifest, target, resources, contents);
+    const obligations = new Map(manifest.semantic_proof_obligations.map((item) => [item.key, item]));
+    for (const projection of projections)
+        validateRuleObligations(projection, obligations, properties, oracles, environments, target, resources, contents);
+    assertSameSet([...obligations.keys()], projections.flatMap((projection) => projection.rule.semantic_obligation_refs), "v2_semantic_obligation_set_mismatch", manifest.target_key);
+}
+function validateRuleObligations(projection, obligations, properties, oracles, environments, target, resources, contents) {
+    const { rule } = projection;
+    const property = properties.get(rule.property_ref);
+    const local = rule.semantic_obligation_refs.map((ref) => {
+        const obligation = obligations.get(ref);
+        if (!obligation)
+            invalid("v2_rule_obligation_unknown", `${rule.key}:${ref}`);
+        return obligation;
+    });
+    assertSameSet(local.map((item) => item.method), property.required_methods, "v2_rule_required_methods_mismatch", rule.key);
+    for (const obligation of local)
+        validateObligation(obligation, projection, property, oracles, environments, target, resources, contents);
+}
+function validateObligation(obligation, projection, property, oracles, environments, target, resources, contents) {
+    if (obligation.fact_rule_ref !== projection.rule.key ||
+        obligation.region_sha256 !== projection.compiled_region.canonical_sha256)
+        invalid("v2_obligation_rule_region_mismatch", obligation.key);
+    const expectedKey = designResourceSymbolicObligationKey(omitKey(obligation));
+    if (obligation.key !== expectedKey)
+        invalid("v2_obligation_identity_mismatch", `${obligation.key}:${expectedKey}`);
+    const oracle = oracles.get(obligation.oracle_ref);
+    if (!oracle)
+        invalid("v2_obligation_oracle_unknown", obligation.key);
+    const environment = environments.get(obligation.environment_ref);
+    if (!environment)
+        invalid("v2_obligation_environment_unknown", obligation.key);
+    validateSymbolicObligationPolicy(obligation, projection.rule, property, oracle, environment, target, resources, contents);
+}
+export function validateSymbolicCertificates(manifest, projections, indexes, compilation, target, resources, contents) {
+    const byRule = new Map(projections.map((item) => [item.rule.key, item]));
+    assertCanonicalSet(manifest.dependency_edges, [], "v2_dependency_edge_set_mismatch");
+    const coveredRules = [];
+    const coveredAxes = new Set();
+    const coveredEdges = new Set();
+    for (const certificate of manifest.noninterference_certificates) {
+        if (!certificate.fact_rule_refs.length)
+            invalid("v2_certificate_rule_refs_required", certificate.key);
+        const local = certificate.fact_rule_refs.map((ref) => {
+            const projection = byRule.get(ref);
+            if (!projection)
+                invalid("v2_certificate_rule_unknown", `${certificate.key}:${ref}`);
+            return projection;
+        });
+        validateCertificate(manifest, certificate, local, indexes, compilation, target, resources, contents);
+        coveredRules.push(...certificate.fact_rule_refs);
+        certificate.omitted_axis_refs.forEach((ref) => coveredAxes.add(ref));
+        certificate.dependency_edge_refs.forEach((ref) => coveredEdges.add(ref));
+    }
+    assertCertificateCoverage(manifest, projections, coveredRules, coveredEdges);
+    return {
+        coveredOmittedAxes: coveredAxes.size,
+        coveredDependencyEdges: coveredEdges.size,
+    };
+}
+function validateCertificate(manifest, certificate, projections, indexes, compilation, target, resources, contents) {
+    unique(certificate.fact_rule_refs, `v2_certificate_rule_ref_duplicate:${certificate.key}`);
+    unique(certificate.omitted_axis_refs, `v2_certificate_omitted_axis_duplicate:${certificate.key}`);
+    unique(certificate.dependency_edge_refs, `v2_certificate_dependency_edge_duplicate:${certificate.key}`);
+    const expectedAxes = [
+        ...new Set(projections.flatMap((item) => item.compiled_region.omitted_axis_refs)),
+    ].sort(compareText);
+    if (expectedAxes.length &&
+        (!certificate.source_noninterference_proof ||
+            !certificate.production_noninterference_proof))
+        invalid("v2_noninterference_proof_unavailable", `${certificate.key}:${expectedAxes.join(",")}`);
+    assertSameSet(certificate.omitted_axis_refs, expectedAxes, "v2_certificate_omitted_axes_mismatch", certificate.key);
+    assertSameSet(certificate.dependency_edge_refs, [], "v2_certificate_dependency_edges_mismatch", certificate.key);
+    if (certificate.canonical_rule_dag_sha256 !==
+        designResourceSymbolicCombinedRuleDigest(projections))
+        invalid("v2_certificate_rule_digest_mismatch", certificate.key);
+    const expectedKey = designResourceSymbolicCertificateKey(omitKey(certificate));
+    if (certificate.key !== expectedKey)
+        invalid("v2_certificate_identity_mismatch", `${certificate.key}:${expectedKey}`);
+    validateTrustedSymbolicNoninterference(manifest, certificate, projections, indexes, compilation, target, resources, contents);
+}
+function assertCertificateCoverage(manifest, projections, coveredRules, coveredEdges) {
+    assertSameSet(coveredRules, projections.map((item) => item.rule.key), "v2_certificate_rule_coverage_mismatch", manifest.target_key);
+    assertSameSet([...coveredEdges], [], "v2_certificate_edge_coverage_mismatch", manifest.target_key);
+}

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

@@ -0,0 +1,19 @@
+import type { DesignResourceHandoffPreflightV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+import type { CompiledSymbolicDenotationV1, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+import type { SymbolicApplicabilityIndex } from "./design-resource-symbolic-applicability-validation.js";
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import { type SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateSymbolicApplicabilityClosure(manifest: DesignResourceObservableRuleManifestV2, reachable: CompiledSymbolicDenotationV1, indexes: SymbolicManifestIndexes, applicability: SymbolicApplicabilityIndex, compilation: DesignResourceSymbolicCompilationSession): void;
+export declare function validateSymbolicCoverage(parsed: ParsedDesignResourceHandoffV2, manifest: DesignResourceObservableRuleManifestV2): void;
+export declare function validateSymbolicRegionWithinReachable(region: SymbolicDenotationPredicate, reachable: SymbolicDenotationPredicate, label: string, compilation: DesignResourceSymbolicCompilationSession): void;
+export declare function validateSymbolicPopulationAndQuantifier(item: {
+    key: string;
+    population_ref: string | null;
+    quantifier: DesignResourceSymbolicFactRuleV2["quantifier"];
+}, subjectPopulationRef: string | null, populations: Map<string, DesignResourceObservableRuleManifestV2["populations"][number]>): void;
+export declare function validateSymbolicQuantifier(quantifier: DesignResourceSymbolicFactRuleV2["quantifier"], label: string): void;
+export declare function aggregateSymbolicCanonicalMetrics(projections: DesignResourceHandoffPreflightV2["rule_projections"]): {
+    nodes: number;
+    edges: number;
+    bytes: number;
+};

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

@@ -0,0 +1,146 @@
+import { DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS } from "./symbolic-denotation-engine.js";
+import { assertSameSet, compareText, invalid, requireKnownRefs, stableJson, } from "./design-resource-symbolic-validation-support.js";
+import { symbolicSubjectPropertyKey, } from "./design-resource-symbolic-indexes.js";
+export function validateSymbolicApplicabilityClosure(manifest, reachable, indexes, applicability, compilation) {
+    for (const subject of manifest.subjects)
+        for (const property of manifest.properties)
+            validateSubjectPropertyPartition(reachable, subject.key, property.key, indexes, applicability, compilation);
+}
+function validateSubjectPropertyPartition(reachable, subjectRef, propertyRef, indexes, applicability, compilation) {
+    const tupleKey = symbolicSubjectPropertyKey(subjectRef, propertyRef);
+    const regions = [
+        ...(indexes.rulesBySubjectProperty.get(tupleKey) ?? []),
+        ...(indexes.dispositionsBySubjectProperty.get(tupleKey) ?? []),
+    ];
+    const label = `${subjectRef}:${propertyRef}`;
+    if (!applicability.isApplicable(subjectRef, propertyRef)) {
+        if (regions.length)
+            invalid("v2_structural_not_applicable_materialized", label);
+        return;
+    }
+    if (!regions.length)
+        invalid("v2_applicability_remainder_uncovered", label);
+    assertRegionsMutuallyExclusive(regions, compilation);
+    const union = compilation.compile({
+        op: "any",
+        predicates: regions.map((region) => region.region),
+    });
+    if (union.canonical_sha256 !== reachable.canonical_sha256)
+        invalid("v2_effective_region_coverage_gap", label);
+}
+function assertRegionsMutuallyExclusive(regions, compilation) {
+    for (let left = 0; left < regions.length; left += 1)
+        for (let right = left + 1; right < regions.length; right += 1) {
+            const overlap = compilation.compile({
+                op: "all",
+                predicates: [regions[left].region, regions[right].region],
+            });
+            if (overlap.canonical_dag.root_ref !== "terminal.false")
+                invalid("v2_effective_region_overlap", `${regions[left].key}:${regions[right].key}`);
+        }
+}
+export function validateSymbolicCoverage(parsed, manifest) {
+    const rows = parsed.handoff.coverage.filter((row) => row.target_ref === manifest.target_key);
+    if (!rows.length)
+        invalid("v2_coverage_required", manifest.target_key);
+    for (const [code, actual, expected] of coverageSets(rows, manifest))
+        assertSameSet(actual, expected, code, manifest.target_key);
+    requireKnownRefs(rows.flatMap((row) => row.source_item_refs), new Set(parsed.source_item_keys), "v2_coverage_source_item_unknown");
+}
+function coverageSets(rows, manifest) {
+    return [
+        [
+            "v2_coverage_subject_set_mismatch",
+            rows.flatMap((row) => row.subject_or_relation_refs),
+            manifest.subjects.map((item) => item.key),
+        ],
+        [
+            "v2_coverage_property_set_mismatch",
+            rows.flatMap((row) => row.property_refs),
+            manifest.properties.map((item) => item.key),
+        ],
+        [
+            "v2_coverage_rule_set_mismatch",
+            rows.flatMap((row) => row.fact_rule_refs),
+            manifest.fact_rules.map((item) => item.key),
+        ],
+        [
+            "v2_coverage_obligation_set_mismatch",
+            rows.flatMap((row) => row.semantic_obligation_refs),
+            manifest.semantic_proof_obligations.map((item) => item.key),
+        ],
+        [
+            "v2_coverage_certificate_set_mismatch",
+            rows.flatMap((row) => row.certificate_refs),
+            manifest.noninterference_certificates.map((item) => item.key),
+        ],
+    ];
+}
+export function validateSymbolicRegionWithinReachable(region, reachable, label, compilation) {
+    const outside = compilation.compile({
+        op: "all",
+        predicates: [region, { op: "not", predicate: reachable }],
+    });
+    if (outside.canonical_dag.root_ref !== "terminal.false")
+        invalid("v2_region_claims_unreachable", label);
+}
+export function validateSymbolicPopulationAndQuantifier(item, subjectPopulationRef, populations) {
+    if (item.population_ref !== subjectPopulationRef)
+        invalid("v2_population_binding_mismatch", item.key);
+    const expected = item.population_ref
+        ? populations.get(item.population_ref)?.quantifier
+        : { kind: "one", minimum: 1, maximum: 1 };
+    if (!expected || stableJson(item.quantifier) !== stableJson(expected))
+        invalid("v2_quantifier_mismatch", item.key);
+    validateSymbolicQuantifier(item.quantifier, item.key);
+}
+export function validateSymbolicQuantifier(quantifier, label) {
+    const { kind, minimum, maximum } = quantifier;
+    const invalidParameters = kind === "one"
+        ? minimum !== 1 || maximum !== 1
+        : kind === "exactly"
+            ? minimum === null || maximum !== minimum
+            : kind === "at_least"
+                ? minimum === null || maximum !== null
+                : kind === "at_most"
+                    ? minimum !== null || maximum === null
+                    : kind === "range"
+                        ? minimum === null || maximum === null || minimum > maximum
+                        : minimum !== null || maximum !== null;
+    if (invalidParameters)
+        invalid("v2_quantifier_parameters_invalid", label);
+}
+export function aggregateSymbolicCanonicalMetrics(projections) {
+    const nodes = collectCanonicalNodes(projections);
+    const roots = projections
+        .map((projection) => ({
+        rule_ref: projection.rule.key,
+        root_ref: projection.compiled_region.canonical_dag.root_ref,
+    }))
+        .sort((left, right) => compareText(left.rule_ref, right.rule_ref));
+    const canonicalNodes = [...nodes.values()].sort((left, right) => compareText(left.key, right.key));
+    const bytes = Buffer.byteLength(stableJson({
+        schema_version: "design-resource-symbolic-rule-dag-set-v2",
+        roots,
+        nodes: canonicalNodes,
+    }), "utf8");
+    const limit = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS.max_canonical_bytes;
+    if (bytes > limit)
+        invalid("v2_shared_canonical_byte_limit_exceeded", `actual=${bytes}:limit=${limit}`);
+    return {
+        nodes: canonicalNodes.length,
+        edges: canonicalNodes.reduce((total, node) => total + node.edges.length, 0),
+        bytes,
+    };
+}
+function collectCanonicalNodes(projections) {
+    const nodes = new Map();
+    for (const projection of projections)
+        for (const node of projection.compiled_region.canonical_dag.nodes) {
+            const previous = nodes.get(node.key);
+            if (previous && stableJson(previous) !== stableJson(node))
+                invalid("v2_shared_dag_node_collision", node.key);
+            nodes.set(node.key, node);
+        }
+    return nodes;
+}

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

@@ -0,0 +1,5 @@
+import type { DesignResourcePropertyDefinitionV1 } from "./design-resource-fact-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceObservableRuleManifestV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function validateSymbolicInspectorAndResources(manifest: DesignResourceObservableRuleManifestV2, target: ParsedDesignResourceHandoffV2["handoff"]["targets"][number], resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateSymbolicPropertyCatalog(properties: DesignResourcePropertyDefinitionV1[]): void;

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

@@ -0,0 +1,90 @@
+import { DESIGN_RESOURCE_STANDARD_PROPERTIES } from "./design-resource-fact-manifest-catalog.js";
+import { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-validation.js";
+import { assertSameSet, compareText, invalid, stableJson, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicInspectorAndResources(manifest, target, resources, contents) {
+    if ((manifest.inspector.trust === "frozen_executable" &&
+        manifest.inspector.implementation_sha256 === null) ||
+        (manifest.inspector.trust === "named_external_tcb" &&
+            manifest.inspector.implementation_sha256 !== null))
+        invalid("v2_inspector_trust_digest_mismatch", target.key);
+    if (manifest.inspector.traversal !== "complete_enumeration" ||
+        manifest.inspector.dynamic_discovery !== "fully_enumerated")
+        invalid("v2_inspector_incomplete", target.key);
+    if (manifest.inspector.entry_resource_ref !==
+        target.source_profile.entry_resource_ref)
+        invalid("v2_inspector_entry_mismatch", target.key);
+    assertSameSet(manifest.inspector.input_resources.map((item) => item.resource_ref), inspectorInputResourceRefs(manifest, target), "v2_inspector_input_resource_set_mismatch", target.key);
+    for (const input of manifest.inspector.input_resources) {
+        const resource = resources.get(input.resource_ref);
+        if (!resource ||
+            resource.path !== input.path ||
+            resource.sha256 !== input.sha256 ||
+            !contents.has(input.resource_ref))
+            invalid("v2_inspector_input_resource_mismatch", input.resource_ref);
+    }
+    for (const row of manifest.inspector.census) {
+        const resource = resources.get(row.resource_ref);
+        const bytes = contents.get(row.resource_ref);
+        if (!resource || !bytes)
+            invalid("v2_census_resource_unknown", row.key);
+        if (!manifest.inspector.input_resources.some((input) => input.resource_ref === row.resource_ref))
+            invalid("v2_census_resource_outside_inspector_inputs", row.key);
+        resolveDesignResourceLocatorValue({ resource_ref: row.resource_ref, ...row.locator }, resource, bytes, `v2.inspector.census.${row.key}`);
+        if (row.disposition === "covered" && !row.fact_refs.length)
+            invalid("v2_census_rule_refs_required", row.key);
+        if (row.disposition === "non_material" && row.fact_refs.length)
+            invalid("v2_non_material_census_rule_refs_forbidden", row.key);
+        if (row.fact_cell_refs.length)
+            invalid("v2_census_ground_fact_cell_refs_forbidden", row.key);
+    }
+    if (manifest.design_system.disposition === "used") {
+        const resource = resources.get(manifest.design_system.resource_ref);
+        if (!resource || resource.sha256 !== manifest.design_system.sha256)
+            invalid("v2_design_system_resource_mismatch", target.key);
+    }
+}
+function inspectorInputResourceRefs(manifest, target) {
+    const proofArtifactRefs = 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)));
+    return target.resource_refs.filter((ref) => ref !== target.source_profile.fact_manifest_resource_ref &&
+        !proofArtifactRefs.has(ref));
+}
+export function validateSymbolicPropertyCatalog(properties) {
+    const actual = new Map(properties.map((property) => [property.key, property]));
+    for (const standard of DESIGN_RESOURCE_STANDARD_PROPERTIES) {
+        const candidate = actual.get(standard.key);
+        if (!candidate)
+            invalid("v2_standard_property_missing", standard.key);
+        if (stableJson(propertyPolicy(candidate)) !==
+            stableJson(propertyPolicy(standard)))
+            invalid("v2_standard_property_definition_mismatch", standard.key);
+    }
+    for (const property of properties)
+        validatePropertyAuthority(property);
+}
+function validatePropertyAuthority(property) {
+    if (property.standard) {
+        if (!DESIGN_RESOURCE_STANDARD_PROPERTIES.some((item) => item.key === property.key))
+            invalid("v2_unknown_standard_property", property.key);
+        return;
+    }
+    if (!property.key.startsWith("custom.") ||
+        !property.inspector_capability_refs.length ||
+        !property.census_refs.length)
+        invalid("v2_custom_property_authority_incomplete", property.key);
+}
+function propertyPolicy(property) {
+    return {
+        key: property.key,
+        family: property.family,
+        dimension: property.dimension,
+        value_kind: property.value_kind,
+        required_methods: [...property.required_methods].sort(compareText),
+        standard: property.standard,
+        inspector_capability_refs: [...property.inspector_capability_refs].sort(compareText),
+    };
+}

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

@@ -0,0 +1,27 @@
+import type { DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicPopulationV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function parseSymbolicPopulations(value: unknown, label: string): DesignResourceSymbolicPopulationV2[];
+export declare function parseSymbolicFactRules(value: unknown, label: string): DesignResourceSymbolicFactRuleV2[];
+export declare function parseSymbolicObligation(value: unknown, label: string): {
+    key: string;
+    fact_rule_ref: string;
+    method: "accessibility_navigation" | "accessibility_semantics" | "accessibility_visual" | "asset_integrity" | "component_state" | "content" | "design_token" | "gesture_trace" | "haptic_feedback" | "input_method" | "interaction_trace" | "layout_geometry" | "localization" | "motion_timeline" | "responsive_reflow" | "scroll_navigation" | "sound_feedback" | "system_ui" | "visual_pixel";
+    region_sha256: string;
+    proof_surface: string;
+    observation_boundary: string;
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: import("./design-resource-fact-types.js").DesignResourceLocatedDigestV1;
+        tolerance: import("./design-resource-fact-types.js").DesignResourceLocatedDigestV1 | null;
+        mask: import("./design-resource-fact-types.js").DesignResourceLocatedDigestV1 | null;
+    };
+    oracle_ref: string;
+    environment_ref: string;
+    protected_value_policy: string;
+    completion_effect: string;
+};
+export declare function parseSymbolicQuantifier(value: unknown, label: string): {
+    kind: "all" | "any" | "at_least" | "at_most" | "exactly" | "none" | "one" | "range";
+    minimum: number | null;
+    maximum: number | null;
+};

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

@@ -0,0 +1,158 @@
+import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
+import { contractKey, sha256, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
+import { parseSymbolicNonnegativeInteger, parseSymbolicPredicate, } from "./design-resource-symbolic-predicate-shape.js";
+import { array, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
+export function parseSymbolicPopulations(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "kind",
+            "member_subject_refs",
+            "universe",
+            "enumeration",
+            "exclusions",
+            "quantifier",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            kind: literal(row.kind, ["static", "dynamic"], `${itemLabel}.kind`),
+            member_subject_refs: stableKeys(row.member_subject_refs, `${itemLabel}.member_subject_refs`),
+            universe: parseDesignResourceLocatedDigest(row.universe, `${itemLabel}.universe`),
+            enumeration: literal(row.enumeration, ["complete", "symbolic_partition"], `${itemLabel}.enumeration`),
+            exclusions: array(row.exclusions, `${itemLabel}.exclusions`).map((entry, exclusionIndex) => parsePopulationExclusion(entry, `${itemLabel}.exclusions[${exclusionIndex}]`)),
+            quantifier: parseSymbolicQuantifier(row.quantifier, `${itemLabel}.quantifier`),
+        };
+    });
+}
+function parsePopulationExclusion(value, label) {
+    const row = object(value, label, [
+        "key",
+        "region",
+        "basis_refs",
+        "rationale",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        region: parseSymbolicPredicate(row.region, `${label}.region`),
+        basis_refs: stableKeys(row.basis_refs, `${label}.basis_refs`),
+        rationale: string(row.rationale, `${label}.rationale`),
+    };
+}
+export function parseSymbolicFactRules(value, label) {
+    return array(value, label).map((item, index) => parseSymbolicFactRule(item, `${label}[${index}]`));
+}
+function parseSymbolicFactRule(value, label) {
+    const row = object(value, label, [
+        "key",
+        "subject_or_relation_ref",
+        "target_ref",
+        "property_ref",
+        "population_ref",
+        "quantifier",
+        "region",
+        "expected",
+        "value_kind",
+        "provenance_ref",
+        "observation_scope",
+        "observation_sensitivity",
+        "lineage",
+        "evidence_refs",
+        "census_refs",
+        "source_item_refs",
+        "semantic_obligation_refs",
+    ]);
+    const lineage = object(row.lineage, `${label}.lineage`, [
+        "design_system_ref",
+        "token_chain_refs",
+        "override_chain_refs",
+        "resolved_value",
+        "conflict_status",
+        "conflict_resolution",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        subject_or_relation_ref: stableKey(row.subject_or_relation_ref, `${label}.subject_or_relation_ref`),
+        target_ref: contractKey(row.target_ref, `${label}.target_ref`),
+        property_ref: stableKey(row.property_ref, `${label}.property_ref`),
+        population_ref: nullable(row.population_ref, (entry) => stableKey(entry, `${label}.population_ref`)),
+        quantifier: parseSymbolicQuantifier(row.quantifier, `${label}.quantifier`),
+        region: parseSymbolicPredicate(row.region, `${label}.region`),
+        expected: parseDesignResourceLocatedDigest(row.expected, `${label}.expected`),
+        value_kind: stableKey(row.value_kind, `${label}.value_kind`),
+        provenance_ref: string(row.provenance_ref, `${label}.provenance_ref`),
+        observation_scope: literal(row.observation_scope, ["subject", "full_target"], `${label}.observation_scope`),
+        observation_sensitivity: literal(row.observation_sensitivity, ["plain", "protected"], `${label}.observation_sensitivity`),
+        lineage: {
+            design_system_ref: nullable(lineage.design_system_ref, (entry) => stableKey(entry, `${label}.lineage.design_system_ref`)),
+            token_chain_refs: stableKeys(lineage.token_chain_refs, `${label}.lineage.token_chain_refs`),
+            override_chain_refs: stableKeys(lineage.override_chain_refs, `${label}.lineage.override_chain_refs`),
+            resolved_value: parseDesignResourceLocatedDigest(lineage.resolved_value, `${label}.lineage.resolved_value`),
+            conflict_status: literal(lineage.conflict_status, ["none", "resolved"], `${label}.lineage.conflict_status`),
+            conflict_resolution: string(lineage.conflict_resolution, `${label}.lineage.conflict_resolution`),
+        },
+        evidence_refs: stableKeys(row.evidence_refs, `${label}.evidence_refs`),
+        census_refs: stableKeys(row.census_refs, `${label}.census_refs`),
+        source_item_refs: sourceItemKeys(row.source_item_refs, `${label}.source_item_refs`),
+        semantic_obligation_refs: stableKeys(row.semantic_obligation_refs, `${label}.semantic_obligation_refs`),
+    };
+}
+export function parseSymbolicObligation(value, label) {
+    const row = object(value, label, [
+        "key",
+        "fact_rule_ref",
+        "method",
+        "region_sha256",
+        "proof_surface",
+        "observation_boundary",
+        "comparison",
+        "oracle_ref",
+        "environment_ref",
+        "protected_value_policy",
+        "completion_effect",
+    ]);
+    const comparison = object(row.comparison, `${label}.comparison`, [
+        "comparator",
+        "mode",
+        "parameters",
+        "tolerance",
+        "mask",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        fact_rule_ref: stableKey(row.fact_rule_ref, `${label}.fact_rule_ref`),
+        method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+        region_sha256: sha256(row.region_sha256, `${label}.region_sha256`),
+        proof_surface: string(row.proof_surface, `${label}.proof_surface`),
+        observation_boundary: string(row.observation_boundary, `${label}.observation_boundary`),
+        comparison: {
+            comparator: string(comparison.comparator, `${label}.comparison.comparator`),
+            mode: literal(comparison.mode, ["exact", "tolerance"], `${label}.comparison.mode`),
+            parameters: parseDesignResourceLocatedDigest(comparison.parameters, `${label}.comparison.parameters`),
+            tolerance: nullable(comparison.tolerance, (entry) => parseDesignResourceLocatedDigest(entry, `${label}.comparison.tolerance`)),
+            mask: nullable(comparison.mask, (entry) => parseDesignResourceLocatedDigest(entry, `${label}.comparison.mask`)),
+        },
+        oracle_ref: stableKey(row.oracle_ref, `${label}.oracle_ref`),
+        environment_ref: stableKey(row.environment_ref, `${label}.environment_ref`),
+        protected_value_policy: string(row.protected_value_policy, `${label}.protected_value_policy`),
+        completion_effect: string(row.completion_effect, `${label}.completion_effect`),
+    };
+}
+export function parseSymbolicQuantifier(value, label) {
+    const row = object(value, label, ["kind", "minimum", "maximum"]);
+    return {
+        kind: literal(row.kind, [
+            "one",
+            "all",
+            "any",
+            "none",
+            "exactly",
+            "at_least",
+            "at_most",
+            "range",
+        ], `${label}.kind`),
+        minimum: nullable(row.minimum, (entry) => parseSymbolicNonnegativeInteger(entry, `${label}.minimum`)),
+        maximum: nullable(row.maximum, (entry) => parseSymbolicNonnegativeInteger(entry, `${label}.maximum`)),
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { DesignResourceHandoffPreflightV2, DesignResourceObservableRuleManifestV2 } from "./design-resource-symbolic-fact-types.js";
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import type { CompiledSymbolicDenotationV1 } from "./symbolic-denotation-types.js";
+export declare function validateSymbolicReadinessClosure(manifest: DesignResourceObservableRuleManifestV2): void;
+export declare function assertNoUnprovedOmittedAxes(compiled: CompiledSymbolicDenotationV1, label: string): void;
+export declare function validateSymbolicExactTargetCoverage(interpretation: "exact_target" | "constraint", manifest: DesignResourceObservableRuleManifestV2, projections: DesignResourceHandoffPreflightV2["rule_projections"], reachable: CompiledSymbolicDenotationV1, compilation: DesignResourceSymbolicCompilationSession): void;