project-tiny-context-harness 0.11.0 → 0.12.0

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

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

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

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

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

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

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

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

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

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

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

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