project-tiny-context-harness 0.8.10 → 0.8.12

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

@@ -0,0 +1,123 @@
+import { stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { array, boolean, literal, object, } from "./long-task-shape-primitives.js";
+export function parseSymbolicAxisDomains(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const kindValue = object(item, itemLabel, ["key", "kind"], ["values", "minimum", "maximum", "integer"]).kind;
+        if (kindValue === "enum") {
+            const row = object(item, itemLabel, ["key", "kind", "values"]);
+            return {
+                key: stableKey(row.key, `${itemLabel}.key`),
+                kind: literal(row.kind, ["enum"], `${itemLabel}.kind`),
+                values: stableKeys(row.values, `${itemLabel}.values`),
+            };
+        }
+        const row = object(item, itemLabel, [
+            "key",
+            "kind",
+            "minimum",
+            "maximum",
+            "integer",
+        ]);
+        return {
+            key: stableKey(row.key, `${itemLabel}.key`),
+            kind: literal(row.kind, ["bounded_number"], `${itemLabel}.kind`),
+            minimum: parseSymbolicSafeInteger(row.minimum, `${itemLabel}.minimum`),
+            maximum: parseSymbolicSafeInteger(row.maximum, `${itemLabel}.maximum`),
+            integer: parseLiteralBooleanTrue(row.integer, `${itemLabel}.integer`),
+        };
+    });
+}
+export function parseSymbolicPredicate(value, label) {
+    const operator = object(value, label, ["op"], [
+        "axis_ref",
+        "value",
+        "values",
+        "minimum",
+        "maximum",
+        "minimum_inclusive",
+        "maximum_inclusive",
+        "predicates",
+        "predicate",
+    ]).op;
+    if (operator === "eq")
+        return parseEquality(value, label);
+    if (operator === "in")
+        return parseMembership(value, label);
+    if (operator === "range")
+        return parseRange(value, label);
+    if (operator === "all" || operator === "any")
+        return parseGroup(value, label);
+    if (operator === "not")
+        return parseNegation(value, label);
+    throw new Error(`design_resource_symbolic_manifest_invalid:${label}.op:unknown:${String(operator)}`);
+}
+function parseEquality(value, label) {
+    const row = object(value, label, ["op", "axis_ref", "value"]);
+    return {
+        op: "eq",
+        axis_ref: stableKey(row.axis_ref, `${label}.axis_ref`),
+        value: parseSymbolicScalar(row.value, `${label}.value`),
+    };
+}
+function parseMembership(value, label) {
+    const row = object(value, label, ["op", "axis_ref", "values"]);
+    return {
+        op: "in",
+        axis_ref: stableKey(row.axis_ref, `${label}.axis_ref`),
+        values: array(row.values, `${label}.values`).map((entry, index) => parseSymbolicScalar(entry, `${label}.values[${index}]`)),
+    };
+}
+function parseRange(value, label) {
+    const row = object(value, label, [
+        "op",
+        "axis_ref",
+        "minimum",
+        "maximum",
+        "minimum_inclusive",
+        "maximum_inclusive",
+    ]);
+    return {
+        op: "range",
+        axis_ref: stableKey(row.axis_ref, `${label}.axis_ref`),
+        minimum: parseSymbolicSafeInteger(row.minimum, `${label}.minimum`),
+        maximum: parseSymbolicSafeInteger(row.maximum, `${label}.maximum`),
+        minimum_inclusive: boolean(row.minimum_inclusive, `${label}.minimum_inclusive`),
+        maximum_inclusive: boolean(row.maximum_inclusive, `${label}.maximum_inclusive`),
+    };
+}
+function parseGroup(value, label) {
+    const row = object(value, label, ["op", "predicates"]);
+    return {
+        op: literal(row.op, ["all", "any"], `${label}.op`),
+        predicates: array(row.predicates, `${label}.predicates`).map((entry, index) => parseSymbolicPredicate(entry, `${label}.predicates[${index}]`)),
+    };
+}
+function parseNegation(value, label) {
+    const row = object(value, label, ["op", "predicate"]);
+    return {
+        op: "not",
+        predicate: parseSymbolicPredicate(row.predicate, `${label}.predicate`),
+    };
+}
+export function parseSymbolicScalar(value, label) {
+    if (typeof value === "string")
+        return stableKey(value, label);
+    return parseSymbolicSafeInteger(value, label);
+}
+export function parseSymbolicSafeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+        throw new Error(`design_resource_symbolic_manifest_invalid:${label}:safe_integer_required`);
+    return value;
+}
+export function parseSymbolicNonnegativeInteger(value, label) {
+    const parsed = parseSymbolicSafeInteger(value, label);
+    if (parsed < 0)
+        throw new Error(`design_resource_symbolic_manifest_invalid:${label}:nonnegative_required`);
+    return parsed;
+}
+function parseLiteralBooleanTrue(value, label) {
+    if (boolean(value, label) !== true)
+        throw new Error(`design_resource_symbolic_manifest_invalid:${label}:must_be_true`);
+    return true;
+}

package/dist/lib/design-resource-symbolic-production-closure.d.ts

@@ -0,0 +1,4 @@
+import { Buffer } from "node:buffer";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceSymbolicHandoffTargetV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1 } from "./design-resource-symbolic-fact-types.js";
+export declare function productionClosureFailure(target: DesignResourceSymbolicHandoffTargetV2, certificate: DesignResourceSymbolicNoninterferenceCertificateV2, resources: ReadonlyMap<string, DesignResource>, contents: ReadonlyMap<string, Buffer>): DesignResourceSymbolicNoninterferenceFailureWitnessV1 | null;

package/dist/lib/design-resource-symbolic-production-closure.js

@@ -0,0 +1,144 @@
+import { Buffer } from "node:buffer";
+import { symbolicNoninterferenceCertificateScopeSha256 } from "./design-resource-symbolic-noninterference-scope.js";
+import { DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE } from "./design-resource-symbolic-source-ir-types.js";
+import { canonicalJson } from "./strict-codec.js";
+const SAFE_STATIC_HTML_TAGS = new Set([
+    "article",
+    "aside",
+    "body",
+    "br",
+    "div",
+    "footer",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "html",
+    "li",
+    "main",
+    "nav",
+    "ol",
+    "p",
+    "section",
+    "span",
+    "strong",
+    "ul",
+]);
+const SAFE_STATIC_HTML_ATTRIBUTE = /^(?:aria-[a-z0-9-]+|class|data-[a-z0-9-]+|dir|id|lang|role|title)$/u;
+const HTML_TOKEN = /<!doctype\s+html\s*>|<\/?[A-Za-z][A-Za-z0-9]*\b[^<>]*>/giu;
+const HTML_TAG = /^<(\/)?([A-Za-z][A-Za-z0-9]*)([^<>]*)>$/u;
+const HTML_ATTRIBUTE = /\s+([A-Za-z_:][A-Za-z0-9_.:-]*)(?:\s*=\s*(?:"[^"]*"|'[^']*'))?/guy;
+export function productionClosureFailure(target, certificate, resources, contents) {
+    for (const resourceRef of target.resource_refs) {
+        const resource = resources.get(resourceRef);
+        const bytes = contents.get(resourceRef);
+        if (!resource || !bytes)
+            continue;
+        if (resourceRef === target.source_profile.entry_resource_ref) {
+            if (resource.media_type !== "text/html")
+                return witness(certificate, resource, null, `unsupported_entry_media:${resource.media_type}`);
+            const failure = staticHtmlFailure(bytes.toString("utf8"));
+            if (failure)
+                return witness(certificate, resource, failure.offset, failure.detail, bytes.toString("utf8"));
+            continue;
+        }
+        if (resource.media_type !== "application/json" &&
+            resource.media_type !== DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE)
+            return witness(certificate, resource, null, `unsupported_dependency_media:${resource.media_type}`);
+        try {
+            const parsed = JSON.parse(bytes.toString("utf8"));
+            if (resource.media_type === DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE &&
+                canonicalJson(parsed) !== bytes.toString("utf8"))
+                return witness(certificate, resource, null, "noncanonical_symbolic_source_ir");
+        }
+        catch {
+            return witness(certificate, resource, null, "invalid_inert_json");
+        }
+    }
+    return null;
+}
+function staticHtmlFailure(source) {
+    let cursor = 0;
+    let doctypeSeen = false;
+    for (const match of source.matchAll(HTML_TOKEN)) {
+        const token = match[0];
+        const offset = match.index;
+        if (source.slice(cursor, offset).includes("<"))
+            return {
+                offset: cursor + source.slice(cursor, offset).indexOf("<"),
+                detail: "unsupported_html_token",
+            };
+        cursor = offset + token.length;
+        if (/^<!doctype/iu.test(token)) {
+            if (doctypeSeen || source.slice(0, offset).trim())
+                return { offset, detail: "misplaced_or_duplicate_doctype" };
+            doctypeSeen = true;
+            continue;
+        }
+        const parsed = HTML_TAG.exec(token);
+        if (!parsed)
+            return { offset, detail: "unsupported_html_token" };
+        const closing = parsed[1] === "/";
+        const tag = parsed[2].toLowerCase();
+        if (!SAFE_STATIC_HTML_TAGS.has(tag))
+            return { offset, detail: `unsupported_html_tag:${tag}` };
+        const attributes = parsed[3];
+        if (closing) {
+            if (attributes.trim())
+                return { offset, detail: "closing_tag_attributes" };
+            continue;
+        }
+        const attributeFailure = staticAttributeFailure(attributes);
+        if (attributeFailure)
+            return {
+                offset: offset + token.indexOf(attributes) + attributeFailure.offset,
+                detail: attributeFailure.detail,
+            };
+    }
+    const remainder = source.slice(cursor);
+    if (remainder.includes("<"))
+        return {
+            offset: cursor + remainder.indexOf("<"),
+            detail: "unsupported_html_token",
+        };
+    return null;
+}
+function staticAttributeFailure(source) {
+    const value = source.endsWith("/") ? source.slice(0, -1) : source;
+    let cursor = 0;
+    HTML_ATTRIBUTE.lastIndex = 0;
+    while (cursor < value.length) {
+        HTML_ATTRIBUTE.lastIndex = cursor;
+        const match = HTML_ATTRIBUTE.exec(value);
+        if (!match || match.index !== cursor)
+            return { offset: cursor, detail: "unsupported_html_attribute_syntax" };
+        const name = match[1].toLowerCase();
+        if (!SAFE_STATIC_HTML_ATTRIBUTE.test(name))
+            return { offset: cursor, detail: `unsupported_html_attribute:${name}` };
+        cursor = HTML_ATTRIBUTE.lastIndex;
+    }
+    return null;
+}
+function witness(certificate, resource, byteOffset, detail, source = "") {
+    const axisRef = certificate.omitted_axis_refs.find((axis) => source.includes(axis));
+    return {
+        kind: axisRef ? "omitted_axis_dependency" : "unsupported_dependency",
+        side: "production",
+        certificate_scope_sha256: symbolicNoninterferenceCertificateScopeSha256(certificate),
+        axis_ref: axisRef ?? null,
+        fact_rule_ref: null,
+        resource_ref: resource.key,
+        path: resource.path,
+        locator: null,
+        node_ref: null,
+        byte_offset: byteOffset === null
+            ? null
+            : Buffer.byteLength(source.slice(0, byteOffset)),
+        assignment: null,
+        detail,
+    };
+}

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;