project-tiny-context-harness 0.8.11 → 0.8.12

package/dist/lib/semantic-fact-policy-census.js

@@ -32,6 +32,49 @@ export function validateSemanticFactInspectorCensus(manifest) {
     }
     assertSameSemanticFactSet([...actual], [...expected.keys()], "inspector_census_universe");
 }
+export function buildSemanticFactInspectorCensus(manifest) {
+    const factsFor = (predicate) => manifest.facts.filter(predicate).map((item) => item.key);
+    return [...expectedCensusRows(manifest, factsFor).entries()].map(([identity, expectation]) => {
+        const separator = identity.indexOf(":");
+        const kind = identity.slice(0, separator);
+        const key = identity.slice(separator + 1);
+        const basisRefs = censusBasisRefs(kind, expectation.row, expectation.fact_refs, manifest);
+        return {
+            key,
+            kind,
+            locator: {
+                material_ref: manifest.key,
+                kind: "manifest_pointer",
+                value: expectation.pointer,
+            },
+            identity_sha256: sha256Hex(canonicalValueJson(expectation.row)),
+            disposition: expectation.fact_refs.length
+                ? "material_with_facts"
+                : "supporting_only",
+            fact_refs: expectation.fact_refs,
+            basis_refs: basisRefs,
+            rationale: expectation.fact_refs.length
+                ? "This census identity contributes to an exact semantic Fact."
+                : "This identity is explicitly inventoried as supporting or inapplicable.",
+        };
+    });
+}
+function censusBasisRefs(kind, row, factRefs, manifest) {
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+        const record = row;
+        for (const field of ["basis_refs", "source_item_refs"])
+            if (Array.isArray(record[field]) &&
+                record[field].every((item) => typeof item === "string") &&
+                record[field].length)
+                return [...record[field]];
+    }
+    if (kind === "proof_obligation" && factRefs.length) {
+        const fact = manifest.facts.find((item) => item.key === factRefs[0]);
+        if (fact?.source_item_refs.length)
+            return [...fact.source_item_refs];
+    }
+    return [manifest.scope.source_item_refs[0]];
+}
 function expectedCensusRows(manifest, factsFor) {
     const result = new Map();
     const add = (kind, key, pointer, row, factRefs) => result.set(`${kind}:${key}`, {

package/dist/lib/semantic-fact-proof-shape.d.ts

@@ -31,7 +31,7 @@ export declare function parseSemanticFactProofObligations(value: unknown, label:
     method: string;
     authority: "external_confirmation" | "machine";
     proof_surface: "api_contract" | "data_state" | "implementation_structure" | "population_coverage" | "runtime_behavior" | "security_boundary" | "ui_browser";
-    evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
     comparison: {
         comparator: string;
         mode: "exact" | "tolerance";

package/dist/lib/semantic-fact-property-shape.d.ts

@@ -5,7 +5,7 @@ export declare function parseSemanticFactPropertyDispositions(value: unknown, la
     standard: boolean;
     value_kind: "boolean" | "custom" | "decision_table" | "digest" | "duration" | "enum" | "formula" | "number" | "object" | "ordered_list" | "range" | "rate" | "ratio" | "relation" | "schema" | "set" | "string" | "timestamp" | "trace";
     required_methods: string[];
-    required_evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    required_evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
     applicable_unit_refs: string[];
     not_applicable_unit_refs: string[];
     decision_required_unit_refs: string[];

package/dist/lib/semantic-fact-source-parser.d.ts

@@ -1,9 +1,14 @@
+import { type SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
 export interface ParsedSemanticFactManifestV1 {
     source_path: string;
     line: number;
     manifest: SemanticFactManifestV1;
     sha256: string;
+    carrier: "expanded_v1" | "compact_v1";
+    fact_revisions: SemanticFactRevisionIdentityV1[];
+    obligation_revisions: SemanticFactRevisionIdentityV1[];
 }
 export declare function parseSemanticFactManifestBlocks(sourcePath: string, content: string): ParsedSemanticFactManifestV1[];
+export declare function parseSemanticFactManifestBlocksForMigration(sourcePath: string, content: string): ParsedSemanticFactManifestV1[];
 export declare function loadSemanticFactManifest(repository: string, sourcePaths: string[]): Promise<ParsedSemanticFactManifestV1>;

package/dist/lib/semantic-fact-source-parser.js

@@ -1,37 +1,78 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { indexSemanticFactRevisionInputs, parseSemanticFactCompactCarrierForMigration, parseSemanticFactCompactCarrierShape, semanticFactRevisionDigest, semanticObligationRevisionDigest, } from "./semantic-fact-compact-carrier.js";
 import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
 import { canonicalValueJson, parseStrictYaml, sha256Hex, } from "./strict-codec.js";
-const START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
+const START = /^\s*```yaml[ \t]+(semantic-fact-manifest-v1|semantic-fact-compact-carrier-v1)[ \t]*$/u;
 const END = /^\s*```[ \t]*$/u;
 export function parseSemanticFactManifestBlocks(sourcePath, content) {
+    return parseSemanticFactManifestBlocksWithMode(sourcePath, content, false);
+}
+export function parseSemanticFactManifestBlocksForMigration(sourcePath, content) {
+    return parseSemanticFactManifestBlocksWithMode(sourcePath, content, true);
+}
+function parseSemanticFactManifestBlocksWithMode(sourcePath, content, allowLegacyRevisionIdentity) {
     const rows = [];
     const lines = content.replace(/\r\n?/gu, "\n").split("\n");
     let open = null;
     for (const [index, line] of lines.entries()) {
         if (!open) {
-            if (START.test(line))
-                open = { line: index + 1, lines: [] };
+            const match = START.exec(line);
+            if (match)
+                open = { line: index + 1, lines: [], kind: match[1] };
             continue;
         }
         if (!END.test(line)) {
             open.lines.push(line);
             continue;
         }
-        const manifest = parseSemanticFactManifestShape(parseStrictYaml(open.lines.join("\n")));
+        const decoded = parseStrictYaml(open.lines.join("\n"));
+        const compact = open.kind === "semantic-fact-compact-carrier-v1";
+        const materialized = compact
+            ? allowLegacyRevisionIdentity
+                ? parseSemanticFactCompactCarrierForMigration(decoded)
+                : parseSemanticFactCompactCarrierShape(decoded)
+            : null;
+        const manifest = materialized
+            ? materialized.manifest
+            : parseSemanticFactManifestShape(decoded);
+        const expandedRevisions = materialized
+            ? null
+            : semanticFactRevisionIdentities(manifest);
         rows.push({
             source_path: sourcePath,
             line: open.line,
             manifest,
-            sha256: sha256Hex(canonicalValueJson(manifest)),
+            sha256: sha256Hex(canonicalValueJson(compact ? decoded : manifest)),
+            carrier: compact ? "compact_v1" : "expanded_v1",
+            fact_revisions: materialized?.fact_revisions ?? expandedRevisions.facts,
+            obligation_revisions: materialized?.obligation_revisions ?? expandedRevisions.obligations,
         });
         open = null;
     }
     if (open)
-        throw new Error(`source_formal_block_unclosed:${sourcePath}:semantic-fact-manifest-v1:${open.line}`);
+        throw new Error(`source_formal_block_unclosed:${sourcePath}:${open.kind}:${open.line}`);
     return rows;
 }
+function semanticFactRevisionIdentities(manifest) {
+    const inputRevisionsByFact = indexSemanticFactRevisionInputs(manifest.inputs);
+    const facts = manifest.facts.map((fact) => ({
+        key: fact.key,
+        revision_digest: semanticFactRevisionDigest(fact, inputRevisionsByFact),
+    }));
+    const factRevisionByKey = new Map(facts.map((item) => [item.key, item.revision_digest]));
+    const obligations = manifest.proof_obligations.map((proof) => {
+        const factRevision = factRevisionByKey.get(proof.fact_ref);
+        if (!factRevision)
+            throw new Error(`semantic_fact_revision_unknown_fact:${proof.key}:${proof.fact_ref}`);
+        return {
+            key: proof.key,
+            revision_digest: semanticObligationRevisionDigest(proof, factRevision),
+        };
+    });
+    return { facts, obligations };
+}
 export async function loadSemanticFactManifest(repository, sourcePaths) {
     const rows = [];
     for (const [index, sourcePath] of sourcePaths.entries()) {

package/dist/lib/structural-closure-cost.d.ts

@@ -0,0 +1,79 @@
+export interface StructuralClosureCostBaseline {
+    schema_version: "structural-closure-cost-baseline-v1";
+    workload: string;
+    exact: {
+        K_fact: number;
+        K_rule: number;
+        M_value: number;
+        M_total: number;
+    };
+    maximum: {
+        N_dag: number;
+        source_bytes: number;
+        contract_bytes: number;
+        evidence_bytes: number;
+        default_context_bytes: number;
+        revision_changed_files: number;
+        revision_changed_lines: number;
+        revision_changed_bytes: number;
+    };
+    minimum: {
+        source_duplicate_saved_bytes: number;
+        contract_duplicate_saved_bytes: number;
+    };
+    profiles: Record<string, {
+        compile_ms: number;
+        preflight_ms: number;
+        final_gate_ms: number;
+        peak_rss_bytes: number;
+    }>;
+}
+export interface StructuralClosureCostObservation {
+    cardinality: {
+        K_fact: number;
+        K_rule: number;
+        M_value: number;
+        M_total: number;
+        N_dag: number;
+    };
+    bytes: {
+        source: number;
+        contract: number;
+        evidence: number;
+        default_context: number;
+    };
+    phases_ms: {
+        compile: number;
+        preflight: number;
+        final_gate: number;
+    };
+    peak_rss_bytes: number;
+    duplicate_blocks: {
+        source: {
+            saved_bytes: number;
+            remaining_beneficial_candidates: number;
+        };
+        contract: {
+            saved_bytes: number;
+            remaining_beneficial_candidates: number;
+        };
+    };
+    revision_blast_radius: {
+        changed_files: number;
+        changed_lines: number;
+        changed_bytes: number;
+        changed_fact_revision_keys: string[];
+        expected_changed_fact_revision_keys: string[];
+        changed_obligation_revision_keys: string[];
+        expected_changed_obligation_revision_keys: string[];
+        unrelated_fact_revision_identities_unchanged: boolean;
+        unrelated_obligation_revision_identities_unchanged: boolean;
+        shared_structure_catalog_unchanged: boolean;
+    };
+    unrelated_axis: {
+        K_fact_growth: number;
+        M_value_growth: number;
+        persisted_shared_metadata_growth_bytes: number;
+    };
+}
+export declare function evaluateStructuralClosureCost(observation: StructuralClosureCostObservation, baseline: StructuralClosureCostBaseline, profile: string): string[];

package/dist/lib/structural-closure-cost.js

@@ -0,0 +1,91 @@
+export function evaluateStructuralClosureCost(observation, baseline, profile) {
+    const findings = [];
+    if (baseline.schema_version !== "structural-closure-cost-baseline-v1")
+        findings.push("baseline_schema_version_invalid");
+    for (const field of ["K_fact", "K_rule", "M_value", "M_total"])
+        if (observation.cardinality[field] !== baseline.exact[field])
+            findings.push(`cardinality_${field}_mismatch:${observation.cardinality[field]}:${baseline.exact[field]}`);
+    compareMaximum(findings, "N_dag", observation.cardinality.N_dag, baseline.maximum.N_dag);
+    for (const [field, value] of [
+        ["source_bytes", observation.bytes.source],
+        ["contract_bytes", observation.bytes.contract],
+        ["evidence_bytes", observation.bytes.evidence],
+        ["default_context_bytes", observation.bytes.default_context],
+    ])
+        compareMaximum(findings, field, value, baseline.maximum[field]);
+    const phaseBudget = baseline.profiles[profile];
+    if (!phaseBudget)
+        findings.push(`baseline_profile_missing:${profile}`);
+    else {
+        compareMaximum(findings, "compile_ms", observation.phases_ms.compile, phaseBudget.compile_ms);
+        compareMaximum(findings, "preflight_ms", observation.phases_ms.preflight, phaseBudget.preflight_ms);
+        compareMaximum(findings, "final_gate_ms", observation.phases_ms.final_gate, phaseBudget.final_gate_ms);
+        compareMaximum(findings, "peak_rss_bytes", observation.peak_rss_bytes, phaseBudget.peak_rss_bytes);
+    }
+    compareMinimum(findings, "source_duplicate_saved_bytes", observation.duplicate_blocks.source.saved_bytes, baseline.minimum.source_duplicate_saved_bytes);
+    compareMinimum(findings, "contract_duplicate_saved_bytes", observation.duplicate_blocks.contract.saved_bytes, baseline.minimum.contract_duplicate_saved_bytes);
+    for (const [side, value] of [
+        [
+            "source",
+            observation.duplicate_blocks.source.remaining_beneficial_candidates,
+        ],
+        [
+            "contract",
+            observation.duplicate_blocks.contract.remaining_beneficial_candidates,
+        ],
+    ])
+        if (value !== 0)
+            findings.push(`remaining_beneficial_candidates:${side}:${value}`);
+    compareMaximum(findings, "revision_changed_files", observation.revision_blast_radius.changed_files, baseline.maximum.revision_changed_files);
+    compareMaximum(findings, "revision_changed_lines", observation.revision_blast_radius.changed_lines, baseline.maximum.revision_changed_lines);
+    compareMaximum(findings, "revision_changed_bytes", observation.revision_blast_radius.changed_bytes, baseline.maximum.revision_changed_bytes);
+    for (const [field, value] of [
+        [
+            "fact_revision_key_set",
+            sameStrings(observation.revision_blast_radius.changed_fact_revision_keys, observation.revision_blast_radius.expected_changed_fact_revision_keys),
+        ],
+        [
+            "obligation_revision_key_set",
+            sameStrings(observation.revision_blast_radius.changed_obligation_revision_keys, observation.revision_blast_radius
+                .expected_changed_obligation_revision_keys),
+        ],
+        [
+            "unrelated_fact_revision_identities",
+            observation.revision_blast_radius
+                .unrelated_fact_revision_identities_unchanged,
+        ],
+        [
+            "unrelated_obligation_revision_identities",
+            observation.revision_blast_radius
+                .unrelated_obligation_revision_identities_unchanged,
+        ],
+        [
+            "shared_structure_catalog",
+            observation.revision_blast_radius.shared_structure_catalog_unchanged,
+        ],
+    ])
+        if (!value)
+            findings.push(`revision_locality_failed:${field}`);
+    for (const [field, value] of [
+        ["K_fact_growth", observation.unrelated_axis.K_fact_growth],
+        ["M_value_growth", observation.unrelated_axis.M_value_growth],
+        [
+            "persisted_shared_metadata_growth_bytes",
+            observation.unrelated_axis.persisted_shared_metadata_growth_bytes,
+        ],
+    ])
+        if (value !== 0)
+            findings.push(`unrelated_axis_growth:${field}:${value}`);
+    return findings.sort();
+}
+function compareMaximum(findings, field, value, maximum) {
+    if (!Number.isFinite(value) || value > maximum)
+        findings.push(`maximum_exceeded:${field}:${value}:${maximum}`);
+}
+function compareMinimum(findings, field, value, minimum) {
+    if (!Number.isFinite(value) || value < minimum)
+        findings.push(`minimum_not_met:${field}:${value}:${minimum}`);
+}
+function sameStrings(left, right) {
+    return JSON.stringify([...left].sort()) === JSON.stringify([...right].sort());
+}

package/dist/lib/symbolic-denotation-dag-builder.d.ts

@@ -0,0 +1,25 @@
+import type { SymbolicDenotationCanonicalDagV1, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+import type { SymbolicRuntimeAxis } from "./symbolic-denotation-runtime.js";
+export declare class SymbolicDecisionDagBuilder {
+    private readonly axes;
+    private readonly limits;
+    private readonly nodes;
+    private readonly unique;
+    private readonly predicateMemo;
+    private readonly applyMemo;
+    private readonly notMemo;
+    private constructedEdges;
+    constructor(axes: SymbolicRuntimeAxis[], limits: SymbolicDenotationComplexityLimits);
+    predicate(predicate: SymbolicDenotationPredicate, domainIndex: ReadonlyMap<string, number>): number;
+    private compilePredicate;
+    private inPredicate;
+    private rangePredicate;
+    private groupPredicate;
+    canonicalize(rootId: number): SymbolicDenotationCanonicalDagV1;
+    private checkCanonicalLimits;
+    private atom;
+    private negate;
+    private apply;
+    private reduceApply;
+    private node;
+}

package/dist/lib/symbolic-denotation-dag-builder.js

@@ -0,0 +1,176 @@
+import { canonicalSymbolicEdges, symbolicSegmentMatches, } from "./symbolic-denotation-runtime.js";
+import { compareText, invalid, neverValue, scalarEqual, sha256, stableJson, } from "./symbolic-denotation-support.js";
+export class SymbolicDecisionDagBuilder {
+    axes;
+    limits;
+    nodes = [
+        { axis_index: -1, child_ids: [] },
+        { axis_index: -1, child_ids: [] },
+    ];
+    unique = new Map();
+    predicateMemo = new Map();
+    applyMemo = new Map();
+    notMemo = new Map();
+    constructedEdges = 0;
+    constructor(axes, limits) {
+        this.axes = axes;
+        this.limits = limits;
+    }
+    predicate(predicate, domainIndex) {
+        const memoKey = stableJson(predicate);
+        const cached = this.predicateMemo.get(memoKey);
+        if (cached !== undefined)
+            return cached;
+        const result = this.compilePredicate(predicate, domainIndex);
+        this.predicateMemo.set(memoKey, result);
+        return result;
+    }
+    compilePredicate(predicate, domainIndex) {
+        switch (predicate.op) {
+            case "eq":
+                return this.atom(predicate.axis_ref, domainIndex, (value) => scalarEqual(value, predicate.value));
+            case "in":
+                return this.inPredicate(predicate, domainIndex);
+            case "range":
+                return this.rangePredicate(predicate, domainIndex);
+            case "not":
+                return this.negate(this.predicate(predicate.predicate, domainIndex));
+            case "all":
+                return this.groupPredicate("and", predicate.predicates, domainIndex);
+            case "any":
+                return this.groupPredicate("or", predicate.predicates, domainIndex);
+            default:
+                return invalid("predicate_operator_unknown", neverValue(predicate));
+        }
+    }
+    inPredicate(predicate, domainIndex) {
+        return this.atom(predicate.axis_ref, domainIndex, (value) => predicate.values.some((candidate) => scalarEqual(value, candidate)));
+    }
+    rangePredicate(predicate, domainIndex) {
+        const minimum = predicate.minimum + (predicate.minimum_inclusive ? 0 : 1);
+        const maximum = predicate.maximum - (predicate.maximum_inclusive ? 0 : 1);
+        return this.atom(predicate.axis_ref, domainIndex, (value) => typeof value === "number" && value >= minimum && value <= maximum);
+    }
+    groupPredicate(operation, predicates, domainIndex) {
+        let result = operation === "and" ? 1 : 0;
+        for (const child of predicates)
+            result = this.apply(operation, result, this.predicate(child, domainIndex));
+        return result;
+    }
+    canonicalize(rootId) {
+        const output = new Map();
+        const memo = new Map([
+            [0, "terminal.false"],
+            [1, "terminal.true"],
+        ]);
+        const visit = (id) => {
+            const cached = memo.get(id);
+            if (cached)
+                return cached;
+            const node = this.nodes[id];
+            const axis = this.axes[node.axis_index];
+            const childRefs = node.child_ids.map(visit);
+            const edges = canonicalSymbolicEdges(axis, childRefs);
+            const body = { axis_ref: axis.domain.key, edges };
+            const key = `node.${sha256(stableJson(body))}`;
+            const existing = output.get(key);
+            if (existing && stableJson(existing.edges) !== stableJson(edges))
+                invalid("canonical_node_hash_collision", key);
+            output.set(key, { key, ...body });
+            memo.set(id, key);
+            return key;
+        };
+        const rootRef = visit(rootId);
+        const nodes = [...output.values()].sort((left, right) => compareText(left.key, right.key));
+        this.checkCanonicalLimits(nodes);
+        return {
+            schema_version: "symbolic-denotation-canonical-dag-v1",
+            root_ref: rootRef,
+            nodes,
+        };
+    }
+    checkCanonicalLimits(nodes) {
+        const partitionEdges = nodes.reduce((total, node) => total + node.edges.length, 0);
+        if (nodes.length > this.limits.max_canonical_dag_nodes)
+            invalid("canonical_dag_node_limit_exceeded", `actual=${nodes.length}:limit=${this.limits.max_canonical_dag_nodes}`);
+        if (partitionEdges > this.limits.max_partition_edges)
+            invalid("canonical_partition_edge_limit_exceeded", `actual=${partitionEdges}:limit=${this.limits.max_partition_edges}`);
+    }
+    atom(axisRef, domainIndex, matches) {
+        const axisIndex = domainIndex.get(axisRef);
+        if (axisIndex === undefined)
+            invalid("predicate_axis_unknown", axisRef);
+        const axis = this.axes[axisIndex];
+        return this.node(axisIndex, axis.segments.map((segment) => symbolicSegmentMatches(segment, matches) ? 1 : 0));
+    }
+    negate(id) {
+        if (id === 0)
+            return 1;
+        if (id === 1)
+            return 0;
+        const cached = this.notMemo.get(id);
+        if (cached !== undefined)
+            return cached;
+        const node = this.nodes[id];
+        const result = this.node(node.axis_index, node.child_ids.map((child) => this.negate(child)));
+        this.notMemo.set(id, result);
+        return result;
+    }
+    apply(operation, left, right) {
+        const reduced = this.reduceApply(operation, left, right);
+        if (reduced !== null)
+            return reduced;
+        const first = Math.min(left, right);
+        const second = Math.max(left, right);
+        const memoKey = `${operation}:${first}:${second}`;
+        const cached = this.applyMemo.get(memoKey);
+        if (cached !== undefined)
+            return cached;
+        const leftNode = this.nodes[left];
+        const rightNode = this.nodes[right];
+        const axisIndex = Math.min(leftNode.axis_index, rightNode.axis_index);
+        const segmentCount = this.axes[axisIndex].segments.length;
+        const children = Array.from({ length: segmentCount }, (_, index) => this.apply(operation, leftNode.axis_index === axisIndex ? leftNode.child_ids[index] : left, rightNode.axis_index === axisIndex ? rightNode.child_ids[index] : right));
+        const result = this.node(axisIndex, children);
+        this.applyMemo.set(memoKey, result);
+        return result;
+    }
+    reduceApply(operation, left, right) {
+        if (left === right)
+            return left;
+        if (operation === "and") {
+            if (left === 0 || right === 0)
+                return 0;
+            if (left === 1)
+                return right;
+            if (right === 1)
+                return left;
+            return null;
+        }
+        if (left === 1 || right === 1)
+            return 1;
+        if (left === 0)
+            return right;
+        if (right === 0)
+            return left;
+        return null;
+    }
+    node(axisIndex, childIds) {
+        if (childIds.every((child) => child === childIds[0]))
+            return childIds[0];
+        const key = `${axisIndex}:${childIds.join(",")}`;
+        const cached = this.unique.get(key);
+        if (cached !== undefined)
+            return cached;
+        const nextNodeCount = this.nodes.length - 1;
+        if (nextNodeCount > this.limits.max_canonical_dag_nodes)
+            invalid("constructed_dag_node_limit_exceeded", `actual=${nextNodeCount}:limit=${this.limits.max_canonical_dag_nodes}`);
+        this.constructedEdges += childIds.length;
+        if (this.constructedEdges > this.limits.max_partition_edges)
+            invalid("constructed_partition_edge_limit_exceeded", `actual=${this.constructedEdges}:limit=${this.limits.max_partition_edges}`);
+        const id = this.nodes.length;
+        this.nodes.push({ axis_index: axisIndex, child_ids: childIds });
+        this.unique.set(key, id);
+        return id;
+    }
+}

package/dist/lib/symbolic-denotation-domain-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits } from "./symbolic-denotation-types.js";
+export declare function validateSymbolicLimits(limits: SymbolicDenotationComplexityLimits): SymbolicDenotationComplexityLimits;
+export declare function validateSymbolicDomains(domainsInput: SymbolicDenotationAxisDomain[]): SymbolicDenotationAxisDomain[];

package/dist/lib/symbolic-denotation-domain-validation.js

@@ -0,0 +1,56 @@
+import { compareText, exactKeys, invalid, stableKey, } from "./symbolic-denotation-support.js";
+export function validateSymbolicLimits(limits) {
+    exactKeys(limits, [
+        "max_predicate_depth",
+        "max_input_predicate_nodes",
+        "max_canonical_dag_nodes",
+        "max_partition_edges",
+        "max_canonical_bytes",
+    ], "complexity_limits");
+    for (const [key, value] of Object.entries(limits))
+        if (!Number.isSafeInteger(value) || value <= 0)
+            invalid("complexity_limit_invalid", `${key}:${value}`);
+    return { ...limits };
+}
+export function validateSymbolicDomains(domainsInput) {
+    if (!Array.isArray(domainsInput) || !domainsInput.length)
+        invalid("axis_domains_required", "");
+    const domains = domainsInput.map(validateDomain);
+    domains.sort((left, right) => compareText(left.key, right.key));
+    if (new Set(domains.map((domain) => domain.key)).size !== domains.length)
+        invalid("axis_domain_key_duplicate", "");
+    return domains;
+}
+function validateDomain(input, index) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        invalid("axis_domain_invalid", String(index));
+    stableKey(input.key, `axis_domain:${index}`);
+    if (input.kind === "enum")
+        return validateEnumDomain(input);
+    if (input.kind === "bounded_number")
+        return validateNumberDomain(input);
+    return invalid("axis_domain_kind_unknown", String(input.kind));
+}
+function validateEnumDomain(input) {
+    exactKeys(input, ["key", "kind", "values"], `axis_domain:${input.key}`);
+    if (!Array.isArray(input.values) || !input.values.length)
+        invalid("enum_domain_values_required", input.key);
+    const values = input.values.map((value) => {
+        if (typeof value !== "string" || !value)
+            invalid("enum_domain_value_invalid", input.key);
+        return value;
+    });
+    if (new Set(values).size !== values.length)
+        invalid("enum_domain_value_duplicate", input.key);
+    return { ...input, values: [...values].sort(compareText) };
+}
+function validateNumberDomain(input) {
+    exactKeys(input, ["key", "kind", "minimum", "maximum", "integer"], `axis_domain:${input.key}`);
+    if (input.integer !== true ||
+        !Number.isSafeInteger(input.minimum) ||
+        !Number.isSafeInteger(input.maximum) ||
+        input.minimum > input.maximum ||
+        input.maximum >= Number.MAX_SAFE_INTEGER)
+        invalid("bounded_number_domain_invalid", input.key);
+    return { ...input };
+}

package/dist/lib/symbolic-denotation-engine.d.ts

@@ -0,0 +1,32 @@
+import type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationCanonicalDagV1, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+export declare const DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS: {
+    readonly max_predicate_depth: 32;
+    readonly max_input_predicate_nodes: 4096;
+    readonly max_canonical_dag_nodes: 8192;
+    readonly max_partition_edges: 65536;
+    readonly max_canonical_bytes: 4194304;
+};
+export declare function compileSymbolicDenotation(domainsInput: SymbolicDenotationAxisDomain[], predicateInput: SymbolicDenotationPredicate, limits?: SymbolicDenotationComplexityLimits): CompiledSymbolicDenotationV1;
+export interface SymbolicDenotationCompilationStatisticsV1 {
+    axis_partition_builds: 1;
+    compile_requests: number;
+    compile_cache_hits: number;
+    unique_compiled_predicates: number;
+}
+export declare class SymbolicDenotationCompilationSession {
+    private readonly limits;
+    private readonly domains;
+    private readonly domainIndex;
+    private readonly numberCuts;
+    private readonly builder;
+    private readonly compiled;
+    private readonly theoreticalGroundCardinality;
+    private compileRequests;
+    private compileCacheHits;
+    constructor(domainsInput: SymbolicDenotationAxisDomain[], seedPredicates: readonly SymbolicDenotationPredicate[], limits?: SymbolicDenotationComplexityLimits);
+    compile(predicateInput: SymbolicDenotationPredicate): CompiledSymbolicDenotationV1;
+    statistics(): SymbolicDenotationCompilationStatisticsV1;
+    private inspect;
+}
+export declare function createSymbolicDenotationCompilationSession(domains: SymbolicDenotationAxisDomain[], seedPredicates: readonly SymbolicDenotationPredicate[], limits?: SymbolicDenotationComplexityLimits): SymbolicDenotationCompilationSession;
+export declare function evaluateCanonicalSymbolicDenotation(dag: SymbolicDenotationCanonicalDagV1, assignment: Record<string, SymbolicDenotationScalar>): boolean;