project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/design-resource-symbolic-noninterference-recompute.js

@@ -0,0 +1,146 @@
+import { compareText, invalid, sha256, stableJson, } from "./design-resource-symbolic-validation-support.js";
+import { sha256Hex } from "./strict-codec.js";
+import { productionClosureFailure } from "./design-resource-symbolic-production-closure.js";
+import { symbolicNoninterferenceCertificateScopeSha256, symbolicNoninterferenceArtifactResourceRefs, symbolicNoninterferenceProductionTargetSnapshot, symbolicNoninterferenceRuleScopeSha256, symbolicNoninterferenceSourceManifestSnapshot, } from "./design-resource-symbolic-noninterference-scope.js";
+import { deriveCurrentSourceNoninterferenceEvidence } from "./design-resource-symbolic-source-ir-oracle.js";
+export function recomputeSymbolicNoninterferenceArtifact(manifest, certificate, proof, target, resources, contents) {
+    const oracle = manifest.oracles.find((item) => item.key === proof.oracle_ref);
+    const environment = manifest.environments.find((item) => item.key === proof.environment_ref);
+    if (!oracle)
+        invalid("v2_noninterference_oracle_unknown", proof.oracle_ref);
+    if (!environment)
+        invalid("v2_noninterference_environment_unknown", proof.environment_ref);
+    const inputs = inputSnapshot(manifest, resources, contents);
+    const certificateScopeSha256 = symbolicNoninterferenceCertificateScopeSha256(certificate);
+    const ruleScopeSha256 = symbolicNoninterferenceRuleScopeSha256(manifest, certificate);
+    const oracleCapability = `symbolic_noninterference.${proof.side}.${proof.method}`;
+    const current = proof.side === "source"
+        ? deriveCurrentSourceNoninterferenceEvidence({
+            manifest,
+            certificate,
+            method: proof.method,
+            target,
+            resources,
+            contents,
+        })
+        : {
+            derived_result: productionDerivedResult(proof),
+            failure_witness: currentProductionDependencyFailure(manifest, certificate, proof, target, resources, contents),
+        };
+    const sourceManifestSnapshotSha256 = proof.side === "source"
+        ? sha256(stableJson(symbolicNoninterferenceSourceManifestSnapshot(manifest)))
+        : null;
+    const methodMaterial = {
+        method: proof.method,
+        oracle_capability: oracleCapability,
+        derived_result: current.derived_result,
+        current_dependency_result: current.failure_witness,
+    };
+    return {
+        schema_version: "design-resource-symbolic-noninterference-artifact-v2",
+        side: proof.side,
+        method: proof.method,
+        oracle_identity: oracle.identity,
+        oracle_version: oracle.version,
+        oracle_implementation_sha256: oracle.sha256 ?? "0".repeat(64),
+        oracle_capability: oracleCapability,
+        environment_sha256: sha256(stableJson(environment)),
+        input_resources: inputs.map((input) => ({
+            resource_ref: input.resource_ref,
+            path: input.path,
+            declared_sha256: input.declared_sha256,
+            current_sha256: input.current_sha256,
+        })),
+        input_snapshot_sha256: sha256(stableJson(inputs)),
+        source_manifest_snapshot_sha256: sourceManifestSnapshotSha256,
+        target_snapshot_sha256: proof.side === "source"
+            ? sourceSnapshot(sourceManifestSnapshotSha256, certificateScopeSha256, ruleScopeSha256, inputs)
+            : productionSnapshot(manifest, target, inputs),
+        certificate_scope_sha256: certificateScopeSha256,
+        rule_scope_sha256: ruleScopeSha256,
+        omitted_axis_refs: [...certificate.omitted_axis_refs].sort(compareText),
+        derived_result: current.derived_result,
+        method_result_sha256: sha256(stableJson(methodMaterial)),
+        verdict: current.failure_witness ? "failed" : "passed",
+        failure_witness: current.failure_witness,
+    };
+}
+function inputSnapshot(manifest, resources, contents) {
+    const artifactRefs = symbolicNoninterferenceArtifactResourceRefs(manifest);
+    return manifest.inspector.input_resources
+        .map((input) => {
+        if (artifactRefs.has(input.resource_ref))
+            invalid("v2_noninterference_artifact_self_reference", input.resource_ref);
+        const resource = resources.get(input.resource_ref);
+        const bytes = contents.get(input.resource_ref);
+        if (!resource ||
+            !bytes ||
+            resource.path !== input.path ||
+            resource.sha256 !== input.sha256)
+            invalid("v2_noninterference_input_resource_missing", input.resource_ref);
+        return {
+            resource_ref: input.resource_ref,
+            path: input.path,
+            declared_sha256: input.sha256,
+            current_sha256: sha256Hex(bytes),
+        };
+    })
+        .sort((left, right) => compareText(left.resource_ref, right.resource_ref));
+}
+function sourceSnapshot(sourceManifestSnapshotSha256, certificateScopeSha256, ruleScopeSha256, inputs) {
+    return sha256(stableJson({
+        source_manifest_snapshot_sha256: sourceManifestSnapshotSha256,
+        certificate_scope_sha256: certificateScopeSha256,
+        rule_scope_sha256: ruleScopeSha256,
+        inputs,
+    }));
+}
+function productionSnapshot(manifest, target, inputs) {
+    return sha256(stableJson({
+        target: symbolicNoninterferenceProductionTargetSnapshot(manifest, target),
+        inputs,
+    }));
+}
+function currentProductionDependencyFailure(manifest, certificate, proof, target, resources, contents) {
+    if (proof.dynamic_dependency_kinds.length ||
+        proof.external_device_refs.length)
+        return unsupportedWitness(certificate, `declared:${[
+            ...proof.dynamic_dependency_kinds,
+            ...proof.external_device_refs,
+        ].join(",")}`);
+    const inputRefs = manifest.inspector.input_resources.map((input) => input.resource_ref);
+    return productionClosureFailure({
+        ...target,
+        resource_refs: inputRefs,
+        source_profile: {
+            ...target.source_profile,
+            dependency_resource_refs: inputRefs.filter((ref) => ref !== target.source_profile.entry_resource_ref),
+        },
+    }, certificate, resources, contents);
+}
+function unsupportedWitness(certificate, detail) {
+    return {
+        kind: "unsupported_dependency",
+        side: "production",
+        certificate_scope_sha256: symbolicNoninterferenceCertificateScopeSha256(certificate),
+        axis_ref: null,
+        fact_rule_ref: null,
+        resource_ref: null,
+        path: null,
+        locator: null,
+        node_ref: null,
+        byte_offset: null,
+        assignment: null,
+        detail,
+    };
+}
+function productionDerivedResult(proof) {
+    return {
+        source_ir_resource_ref: null,
+        static_dependency_nodes: structuredClone(proof.static_dependency_nodes),
+        static_rule_roots: structuredClone(proof.static_rule_roots),
+        equivalence_cases: structuredClone(proof.equivalence_cases),
+        complete_domain_cardinality: proof.complete_domain_cardinality,
+        exhaustive_evaluation_sha256: null,
+    };
+}

package/dist/lib/design-resource-symbolic-noninterference-scope.d.ts

@@ -0,0 +1,7 @@
+import type { DesignResourceObservableRuleManifestV2, DesignResourceSymbolicHandoffTargetV2, DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-fact-types.js";
+export declare function symbolicNoninterferenceCertificateScope(certificate: DesignResourceSymbolicNoninterferenceCertificateV2): Record<string, unknown>;
+export declare function symbolicNoninterferenceCertificateScopeSha256(certificate: DesignResourceSymbolicNoninterferenceCertificateV2): string;
+export declare function symbolicNoninterferenceRuleScopeSha256(manifest: DesignResourceObservableRuleManifestV2, certificate: DesignResourceSymbolicNoninterferenceCertificateV2): string;
+export declare function symbolicNoninterferenceSourceManifestSnapshot(manifest: DesignResourceObservableRuleManifestV2): Record<string, unknown>;
+export declare function symbolicNoninterferenceArtifactResourceRefs(manifest: DesignResourceObservableRuleManifestV2): Set<string>;
+export declare function symbolicNoninterferenceProductionTargetSnapshot(manifest: DesignResourceObservableRuleManifestV2, target: DesignResourceSymbolicHandoffTargetV2): Record<string, unknown>;

package/dist/lib/design-resource-symbolic-noninterference-scope.js

@@ -0,0 +1,49 @@
+import { compareText, sha256, stableJson, } from "./design-resource-symbolic-validation-support.js";
+export function symbolicNoninterferenceCertificateScope(certificate) {
+    const { key: _key, source_noninterference_proof: _sourceProof, production_noninterference_proof: _productionProof, ...scope } = certificate;
+    return {
+        ...scope,
+        fact_rule_refs: [...scope.fact_rule_refs].sort(compareText),
+        omitted_axis_refs: [...scope.omitted_axis_refs].sort(compareText),
+        dependency_edge_refs: [...scope.dependency_edge_refs].sort(compareText),
+    };
+}
+export function symbolicNoninterferenceCertificateScopeSha256(certificate) {
+    return sha256(stableJson(symbolicNoninterferenceCertificateScope(certificate)));
+}
+export function symbolicNoninterferenceRuleScopeSha256(manifest, certificate) {
+    const rules = new Map(manifest.fact_rules.map((rule) => [rule.key, rule]));
+    return sha256(stableJson([...certificate.fact_rule_refs].sort(compareText).map((ruleRef) => ({
+        rule_ref: ruleRef,
+        rule: rules.get(ruleRef) ?? null,
+    }))));
+}
+export function symbolicNoninterferenceSourceManifestSnapshot(manifest) {
+    return {
+        ...manifest,
+        noninterference_certificates: manifest.noninterference_certificates.map(symbolicNoninterferenceCertificateScope),
+    };
+}
+export function symbolicNoninterferenceArtifactResourceRefs(manifest) {
+    return 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)));
+}
+export function symbolicNoninterferenceProductionTargetSnapshot(manifest, target) {
+    const artifacts = symbolicNoninterferenceArtifactResourceRefs(manifest);
+    const semanticInputs = new Set(manifest.inspector.input_resources.map((input) => input.resource_ref));
+    const keep = (ref) => semanticInputs.has(ref) && !artifacts.has(ref);
+    return {
+        ...target,
+        resource_refs: target.resource_refs.filter(keep).sort(compareText),
+        source_profile: {
+            ...target.source_profile,
+            dependency_resource_refs: target.source_profile.dependency_resource_refs
+                .filter(keep)
+                .sort(compareText),
+        },
+    };
+}

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

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

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

@@ -0,0 +1,152 @@
+import { nonnegativeInteger, sha256, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
+import { parseSymbolicPredicate } from "./design-resource-symbolic-predicate-shape.js";
+import { array, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
+export function parseSymbolicNoninterferenceProof(value, label) {
+    const row = object(value, label, [
+        "side",
+        "method",
+        "input_resource_refs",
+        "oracle_ref",
+        "environment_ref",
+        "static_dependency_nodes",
+        "static_rule_roots",
+        "equivalence_cases",
+        "dynamic_dependency_kinds",
+        "external_device_refs",
+        "complete_domain_cardinality",
+        "oracle_version",
+        "oracle_implementation_sha256",
+        "oracle_capability",
+        "environment_sha256",
+        "input_snapshot_sha256",
+        "source_manifest_snapshot_sha256",
+        "target_snapshot_sha256",
+        "certificate_scope_sha256",
+        "rule_scope_sha256",
+        "omitted_axis_refs",
+        "method_result_sha256",
+        "artifact_resource_ref",
+        "artifact_path",
+        "artifact_sha256",
+        "failure_witness",
+    ]);
+    return {
+        side: literal(row.side, ["source", "production"], `${label}.side`),
+        method: literal(row.method, [
+            "closed_world_static_dependency_closure",
+            "restricted_ir_symbolic_equivalence",
+            "finite_complete_domain_exhaustive_equivalence",
+        ], `${label}.method`),
+        input_resource_refs: stableKeys(row.input_resource_refs, `${label}.input_resource_refs`),
+        oracle_ref: stableKey(row.oracle_ref, `${label}.oracle_ref`),
+        environment_ref: stableKey(row.environment_ref, `${label}.environment_ref`),
+        static_dependency_nodes: array(row.static_dependency_nodes, `${label}.static_dependency_nodes`).map((item, index) => parseStaticDependencyNode(item, `${label}.static_dependency_nodes[${index}]`)),
+        static_rule_roots: array(row.static_rule_roots, `${label}.static_rule_roots`).map((item, index) => parseStaticDependencyRoot(item, `${label}.static_rule_roots[${index}]`)),
+        equivalence_cases: array(row.equivalence_cases, `${label}.equivalence_cases`).map((item, index) => {
+            const itemLabel = `${label}.equivalence_cases[${index}]`;
+            const entry = object(item, itemLabel, [
+                "fact_rule_refs",
+                "side_predicate",
+                "axis_erased_predicate",
+            ]);
+            return {
+                fact_rule_refs: stableKeys(entry.fact_rule_refs, `${itemLabel}.fact_rule_refs`),
+                side_predicate: parseSymbolicPredicate(entry.side_predicate, `${itemLabel}.side_predicate`),
+                axis_erased_predicate: parseSymbolicPredicate(entry.axis_erased_predicate, `${itemLabel}.axis_erased_predicate`),
+            };
+        }),
+        dynamic_dependency_kinds: stableKeys(row.dynamic_dependency_kinds, `${label}.dynamic_dependency_kinds`),
+        external_device_refs: stableKeys(row.external_device_refs, `${label}.external_device_refs`),
+        complete_domain_cardinality: nullable(row.complete_domain_cardinality, (entry) => decimalCardinality(entry, `${label}.complete_domain_cardinality`)),
+        oracle_version: string(row.oracle_version, `${label}.oracle_version`),
+        oracle_implementation_sha256: sha256(row.oracle_implementation_sha256, `${label}.oracle_implementation_sha256`),
+        oracle_capability: string(row.oracle_capability, `${label}.oracle_capability`),
+        environment_sha256: sha256(row.environment_sha256, `${label}.environment_sha256`),
+        input_snapshot_sha256: sha256(row.input_snapshot_sha256, `${label}.input_snapshot_sha256`),
+        source_manifest_snapshot_sha256: nullable(row.source_manifest_snapshot_sha256, (entry) => sha256(entry, `${label}.source_manifest_snapshot_sha256`)),
+        target_snapshot_sha256: sha256(row.target_snapshot_sha256, `${label}.target_snapshot_sha256`),
+        certificate_scope_sha256: sha256(row.certificate_scope_sha256, `${label}.certificate_scope_sha256`),
+        rule_scope_sha256: sha256(row.rule_scope_sha256, `${label}.rule_scope_sha256`),
+        omitted_axis_refs: stableKeys(row.omitted_axis_refs, `${label}.omitted_axis_refs`),
+        method_result_sha256: sha256(row.method_result_sha256, `${label}.method_result_sha256`),
+        artifact_resource_ref: stableKey(row.artifact_resource_ref, `${label}.artifact_resource_ref`),
+        artifact_path: string(row.artifact_path, `${label}.artifact_path`),
+        artifact_sha256: sha256(row.artifact_sha256, `${label}.artifact_sha256`),
+        failure_witness: nullable(row.failure_witness, (entry) => parseFailureWitness(entry, `${label}.failure_witness`)),
+    };
+}
+function parseFailureWitness(value, label) {
+    const row = object(value, label, [
+        "kind",
+        "side",
+        "certificate_scope_sha256",
+        "axis_ref",
+        "fact_rule_ref",
+        "resource_ref",
+        "path",
+        "locator",
+        "node_ref",
+        "byte_offset",
+        "assignment",
+        "detail",
+    ]);
+    return {
+        kind: literal(row.kind, [
+            "omitted_axis_dependency",
+            "unsupported_dependency",
+            "source_rule_denotation_mismatch",
+            "complete_domain_counterexample",
+        ], `${label}.kind`),
+        side: literal(row.side, ["source", "production"], `${label}.side`),
+        certificate_scope_sha256: sha256(row.certificate_scope_sha256, `${label}.certificate_scope_sha256`),
+        axis_ref: nullable(row.axis_ref, (entry) => stableKey(entry, `${label}.axis_ref`)),
+        fact_rule_ref: nullable(row.fact_rule_ref, (entry) => stableKey(entry, `${label}.fact_rule_ref`)),
+        resource_ref: nullable(row.resource_ref, (entry) => stableKey(entry, `${label}.resource_ref`)),
+        path: nullable(row.path, (entry) => string(entry, `${label}.path`)),
+        locator: nullable(row.locator, (entry) => string(entry, `${label}.locator`)),
+        node_ref: nullable(row.node_ref, (entry) => stableKey(entry, `${label}.node_ref`)),
+        byte_offset: nullable(row.byte_offset, (entry) => nonnegativeInteger(entry, `${label}.byte_offset`)),
+        assignment: nullable(row.assignment, (entry) => parseAssignment(entry, `${label}.assignment`)),
+        detail: string(row.detail, `${label}.detail`),
+    };
+}
+function parseAssignment(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${label}: must be an object`);
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        stableKey(key, `${label}.key`);
+        if ((typeof entry !== "string" && typeof entry !== "number") ||
+            (typeof entry === "number" && !Number.isFinite(entry)))
+            throw new Error(`${label}.${key}: must be a finite scalar`);
+        result[key] = entry;
+    }
+    return result;
+}
+function parseStaticDependencyNode(value, label) {
+    const row = object(value, label, [
+        "key",
+        "axis_refs",
+        "dependency_refs",
+        "input_resource_refs",
+    ]);
+    return {
+        key: stableKey(row.key, `${label}.key`),
+        axis_refs: stableKeys(row.axis_refs, `${label}.axis_refs`),
+        dependency_refs: stableKeys(row.dependency_refs, `${label}.dependency_refs`),
+        input_resource_refs: stableKeys(row.input_resource_refs, `${label}.input_resource_refs`),
+    };
+}
+function parseStaticDependencyRoot(value, label) {
+    const row = object(value, label, ["fact_rule_refs", "node_ref"]);
+    return {
+        fact_rule_refs: nullable(row.fact_rule_refs, (entry) => stableKeys(entry, `${label}.fact_rule_refs`)),
+        node_ref: stableKey(row.node_ref, `${label}.node_ref`),
+    };
+}
+function decimalCardinality(value, label) {
+    const parsed = string(value, label);
+    if (!/^(?:0|[1-9][0-9]*)$/u.test(parsed))
+        throw new Error(`${label}: must be a canonical nonnegative decimal`);
+    return parsed;
+}

package/dist/lib/design-resource-symbolic-noninterference-types.d.ts

@@ -0,0 +1,103 @@
+import type { SymbolicDenotationPredicate, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+export interface DesignResourceSymbolicNoninterferenceCertificateV2 {
+    key: string;
+    fact_rule_refs: string[];
+    omitted_axis_refs: string[];
+    dependency_edge_refs: string[];
+    canonical_rule_dag_sha256: string;
+    source_noninterference_proof?: DesignResourceSymbolicNoninterferenceProofV2 | null;
+    production_noninterference_proof?: DesignResourceSymbolicNoninterferenceProofV2 | null;
+}
+export type DesignResourceSymbolicNoninterferenceProofMethodV2 = "closed_world_static_dependency_closure" | "restricted_ir_symbolic_equivalence" | "finite_complete_domain_exhaustive_equivalence";
+export interface DesignResourceSymbolicNoninterferenceEquivalenceCaseV2 {
+    fact_rule_refs: string[];
+    side_predicate: SymbolicDenotationPredicate;
+    axis_erased_predicate: SymbolicDenotationPredicate;
+}
+export interface DesignResourceSymbolicStaticDependencyNodeV2 {
+    key: string;
+    axis_refs: string[];
+    dependency_refs: string[];
+    input_resource_refs: string[];
+}
+export interface DesignResourceSymbolicStaticDependencyRootV2 {
+    fact_rule_refs: string[] | null;
+    node_ref: string;
+}
+export interface DesignResourceSymbolicNoninterferenceFailureWitnessV1 {
+    kind: "omitted_axis_dependency" | "unsupported_dependency" | "source_rule_denotation_mismatch" | "complete_domain_counterexample";
+    side: "source" | "production";
+    certificate_scope_sha256: string;
+    axis_ref: string | null;
+    fact_rule_ref: string | null;
+    resource_ref: string | null;
+    path: string | null;
+    locator: string | null;
+    node_ref: string | null;
+    byte_offset: number | null;
+    assignment: Record<string, SymbolicDenotationScalar> | null;
+    detail: string;
+}
+export interface DesignResourceSymbolicNoninterferenceInputBindingV2 {
+    resource_ref: string;
+    path: string;
+    declared_sha256: string;
+    current_sha256: string;
+}
+export interface DesignResourceSymbolicNoninterferenceDerivedResultV2 {
+    source_ir_resource_ref: string | null;
+    static_dependency_nodes: DesignResourceSymbolicStaticDependencyNodeV2[];
+    static_rule_roots: DesignResourceSymbolicStaticDependencyRootV2[];
+    equivalence_cases: DesignResourceSymbolicNoninterferenceEquivalenceCaseV2[];
+    complete_domain_cardinality: string | null;
+    exhaustive_evaluation_sha256: string | null;
+}
+export interface DesignResourceSymbolicNoninterferenceArtifactV2 {
+    schema_version: "design-resource-symbolic-noninterference-artifact-v2";
+    side: "source" | "production";
+    method: DesignResourceSymbolicNoninterferenceProofMethodV2;
+    oracle_identity: string;
+    oracle_version: string;
+    oracle_implementation_sha256: string;
+    oracle_capability: string;
+    environment_sha256: string;
+    input_resources: DesignResourceSymbolicNoninterferenceInputBindingV2[];
+    input_snapshot_sha256: string;
+    source_manifest_snapshot_sha256: string | null;
+    target_snapshot_sha256: string;
+    certificate_scope_sha256: string;
+    rule_scope_sha256: string;
+    omitted_axis_refs: string[];
+    derived_result: DesignResourceSymbolicNoninterferenceDerivedResultV2;
+    method_result_sha256: string;
+    verdict: "passed" | "failed";
+    failure_witness: DesignResourceSymbolicNoninterferenceFailureWitnessV1 | null;
+}
+export interface DesignResourceSymbolicNoninterferenceProofV2 {
+    side: "source" | "production";
+    method: DesignResourceSymbolicNoninterferenceProofMethodV2;
+    input_resource_refs: string[];
+    oracle_ref: string;
+    environment_ref: string;
+    static_dependency_nodes: DesignResourceSymbolicStaticDependencyNodeV2[];
+    static_rule_roots: DesignResourceSymbolicStaticDependencyRootV2[];
+    equivalence_cases: DesignResourceSymbolicNoninterferenceEquivalenceCaseV2[];
+    dynamic_dependency_kinds: string[];
+    external_device_refs: string[];
+    complete_domain_cardinality: string | null;
+    oracle_version: string;
+    oracle_implementation_sha256: string;
+    oracle_capability: string;
+    environment_sha256: string;
+    input_snapshot_sha256: string;
+    source_manifest_snapshot_sha256: string | null;
+    target_snapshot_sha256: string;
+    certificate_scope_sha256: string;
+    rule_scope_sha256: string;
+    omitted_axis_refs: string[];
+    method_result_sha256: string;
+    artifact_resource_ref: string;
+    artifact_path: string;
+    artifact_sha256: string;
+    failure_witness: DesignResourceSymbolicNoninterferenceFailureWitnessV1 | null;
+}

package/dist/lib/design-resource-symbolic-noninterference-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import type { DesignResourceSymbolicCompilationSession } from "./design-resource-symbolic-compilation.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffPreflightV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-fact-types.js";
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateTrustedSymbolicNoninterference(manifest: DesignResourceObservableRuleManifestV2, certificate: DesignResourceSymbolicNoninterferenceCertificateV2, projections: DesignResourceHandoffPreflightV2["rule_projections"], indexes: SymbolicManifestIndexes, compilation: DesignResourceSymbolicCompilationSession, target: DesignResourceHandoffPreflightV2["handoff"]["targets"][number], resources: ReadonlyMap<string, DesignResource>, contents: ReadonlyMap<string, Buffer>): void;

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

@@ -0,0 +1,62 @@
+import { DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES, } from "./design-resource-fact-enums.js";
+import { validateSymbolicNoninterferenceEquivalence } from "./design-resource-symbolic-noninterference-equivalence.js";
+import { validateStaticDependencyClosure } from "./design-resource-symbolic-static-dependency-validation.js";
+import { validateSymbolicNoninterferenceArtifact } from "./design-resource-symbolic-noninterference-artifact.js";
+import { assertSameSet, invalid, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateTrustedSymbolicNoninterference(manifest, certificate, projections, indexes, compilation, target, resources, contents) {
+    if (!certificate.omitted_axis_refs.length) {
+        if (certificate.source_noninterference_proof != null ||
+            certificate.production_noninterference_proof != null)
+            invalid("v2_noninterference_proof_without_omission", certificate.key);
+        return;
+    }
+    const proofs = [
+        ["source", certificate.source_noninterference_proof],
+        ["production", certificate.production_noninterference_proof],
+    ];
+    for (const [side, proof] of proofs) {
+        if (!proof)
+            invalid("v2_noninterference_proof_unavailable", `${certificate.key}:${side}:${certificate.omitted_axis_refs.join(",")}`);
+        validateProof(side, proof, manifest, certificate, projections, indexes, compilation, target, resources, contents);
+    }
+}
+function validateProof(expectedSide, proof, manifest, certificate, projections, indexes, compilation, target, resources, contents) {
+    if (proof.side !== expectedSide)
+        invalid("v2_noninterference_proof_side_mismatch", `${certificate.key}:${expectedSide}:${proof.side}`);
+    assertSameSet(proof.input_resource_refs, manifest.inspector.input_resources.map((item) => item.resource_ref), "v2_noninterference_input_closure_mismatch", `${certificate.key}:${expectedSide}`);
+    if (!indexes.oracles.has(proof.oracle_ref))
+        invalid("v2_noninterference_oracle_unknown", proof.oracle_ref);
+    const oracle = indexes.oracles.get(proof.oracle_ref);
+    if (oracle.trust !== "frozen_executable" || oracle.sha256 === null)
+        invalid("v2_noninterference_frozen_oracle_required", proof.oracle_ref);
+    const requiredCapability = `symbolic_noninterference.${expectedSide}.${proof.method}`;
+    if (!isNoninterferenceOracleCapability(requiredCapability))
+        invalid("v2_noninterference_oracle_capability_unregistered", requiredCapability);
+    if (!oracle.capability_refs.includes(requiredCapability))
+        invalid("v2_noninterference_oracle_capability_missing", `${proof.oracle_ref}:${requiredCapability}`);
+    if (proof.oracle_capability !== requiredCapability)
+        invalid("v2_noninterference_oracle_capability_binding_mismatch", `${certificate.key}:${proof.oracle_capability}:${requiredCapability}`);
+    if (!indexes.environments.has(proof.environment_ref))
+        invalid("v2_noninterference_environment_unknown", proof.environment_ref);
+    if (proof.dynamic_dependency_kinds.length)
+        invalid("v2_noninterference_dynamic_dependency_unproved", `${certificate.key}:${proof.dynamic_dependency_kinds.join(",")}`);
+    if (proof.external_device_refs.length)
+        invalid("v2_noninterference_external_device_unproved", `${certificate.key}:${proof.external_device_refs.join(",")}`);
+    unique(proof.input_resource_refs, `v2_noninterference_input_duplicate:${certificate.key}:${expectedSide}`);
+    unique(proof.dynamic_dependency_kinds, `v2_noninterference_dynamic_dependency_duplicate:${certificate.key}:${expectedSide}`);
+    unique(proof.external_device_refs, `v2_noninterference_external_device_duplicate:${certificate.key}:${expectedSide}`);
+    assertSameSet(proof.omitted_axis_refs, certificate.omitted_axis_refs, "v2_noninterference_artifact_omitted_axis_mismatch", `${certificate.key}:${expectedSide}`);
+    if (expectedSide === "source") {
+        validateSymbolicNoninterferenceArtifact(manifest, certificate, proof, target, resources, contents);
+        return;
+    }
+    if (proof.method === "closed_world_static_dependency_closure") {
+        validateStaticDependencyClosure(proof, certificate, projections, manifest);
+    }
+    else
+        validateSymbolicNoninterferenceEquivalence(proof, manifest, certificate, projections, compilation);
+    validateSymbolicNoninterferenceArtifact(manifest, certificate, proof, target, resources, contents);
+}
+function isNoninterferenceOracleCapability(value) {
+    return DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES.includes(value);
+}

package/dist/lib/design-resource-symbolic-oracle-fingerprint.d.ts

@@ -0,0 +1 @@
+export declare function fingerprintExecutableModuleClosure(entryUrls: readonly string[]): string;

package/dist/lib/design-resource-symbolic-oracle-fingerprint.js

@@ -0,0 +1,47 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const LOCAL_MODULE_IMPORT = /(?:\bfrom\s*|\bimport\s*)["'](\.[^"']+\.js)["']/gu;
+const DYNAMIC_MODULE_IMPORT = /\bimport\s*\(/gu;
+const HIDDEN_LOCAL_LOADER = /\b(?:createRequire|require)\s*\(/gu;
+export function fingerprintExecutableModuleClosure(entryUrls) {
+    const pending = [...new Set(entryUrls)].sort();
+    const seen = new Map();
+    while (pending.length) {
+        const url = pending.shift();
+        if (seen.has(url))
+            continue;
+        const bytes = readFileSync(fileURLToPath(url));
+        const source = bytes.toString("utf8");
+        if (DYNAMIC_MODULE_IMPORT.test(source))
+            throw new Error(`symbolic Oracle implementation uses dynamic import: ${url}`);
+        DYNAMIC_MODULE_IMPORT.lastIndex = 0;
+        if (HIDDEN_LOCAL_LOADER.test(source))
+            throw new Error(`symbolic Oracle implementation uses a hidden local loader: ${url}`);
+        HIDDEN_LOCAL_LOADER.lastIndex = 0;
+        seen.set(url, bytes);
+        for (const specifier of localModuleImports(source)) {
+            const dependencyUrl = new URL(specifier, url).href;
+            if (!seen.has(dependencyUrl))
+                pending.push(dependencyUrl);
+        }
+        pending.sort();
+    }
+    const commonRoot = path.dirname(fileURLToPath([...seen.keys()].sort()[0] ?? entryUrls[0]));
+    const entries = [...seen.entries()]
+        .map(([url, bytes]) => ({
+        path: path
+            .relative(commonRoot, fileURLToPath(url))
+            .replaceAll(path.sep, "/"),
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path, "en"));
+    return createHash("sha256").update(JSON.stringify(entries)).digest("hex");
+}
+function localModuleImports(source) {
+    const result = [];
+    for (const match of source.matchAll(LOCAL_MODULE_IMPORT))
+        result.push(match[1]);
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+export declare function parseSymbolicAxisDomains(value: unknown, label: string): SymbolicDenotationAxisDomain[];
+export declare function parseSymbolicPredicate(value: unknown, label: string): SymbolicDenotationPredicate;
+export declare function parseSymbolicScalar(value: unknown, label: string): string | number;
+export declare function parseSymbolicSafeInteger(value: unknown, label: string): number;
+export declare function parseSymbolicNonnegativeInteger(value: unknown, label: string): number;