project-tiny-context-harness 0.8.11 → 0.8.13

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;

package/dist/lib/symbolic-denotation-engine.js

@@ -0,0 +1,140 @@
+import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
+import { SymbolicDecisionDagBuilder } from "./symbolic-denotation-dag-builder.js";
+import { validateSymbolicDomains, validateSymbolicLimits, } from "./symbolic-denotation-domain-validation.js";
+import { buildSymbolicRuntimeAxes, symbolicEdgeMatches, } from "./symbolic-denotation-runtime.js";
+import { compareText, domainCardinality, invalid, sha256, stableJson, } from "./symbolic-denotation-support.js";
+import { validateSymbolicPredicate, } from "./symbolic-denotation-validation.js";
+export const DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS = {
+    max_predicate_depth: 32,
+    max_input_predicate_nodes: 4_096,
+    max_canonical_dag_nodes: 8_192,
+    max_partition_edges: 65_536,
+    max_canonical_bytes: 4_194_304,
+};
+export function compileSymbolicDenotation(domainsInput, predicateInput, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+    return createSymbolicDenotationCompilationSession(domainsInput, [predicateInput], limits).compile(predicateInput);
+}
+export class SymbolicDenotationCompilationSession {
+    limits;
+    domains;
+    domainIndex;
+    numberCuts = new Map();
+    builder;
+    compiled = new Map();
+    theoreticalGroundCardinality;
+    compileRequests = 0;
+    compileCacheHits = 0;
+    constructor(domainsInput, seedPredicates, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+        if (!seedPredicates.length)
+            invalid("compilation_session_seeds_required", "");
+        this.limits = validateSymbolicLimits(limits);
+        this.domains = validateSymbolicDomains(domainsInput);
+        this.domainIndex = new Map(this.domains.map((domain, index) => [domain.key, index]));
+        const uniqueSeeds = new Map(seedPredicates.map((predicate) => [stableJson(predicate), predicate]));
+        for (const predicate of uniqueSeeds.values())
+            mergeNumberCuts(this.numberCuts, this.inspect(predicate).number_cuts);
+        const axes = buildSymbolicRuntimeAxes(this.domains, this.numberCuts);
+        this.builder = new SymbolicDecisionDagBuilder(axes, this.limits);
+        this.theoreticalGroundCardinality = this.domains
+            .reduce((total, domain) => total * domainCardinality(domain), 1n)
+            .toString();
+    }
+    compile(predicateInput) {
+        this.compileRequests += 1;
+        const inspection = this.inspect(predicateInput);
+        assertKnownNumberCuts(this.numberCuts, inspection.number_cuts);
+        const predicate = validateSymbolicPredicate(predicateInput, this.domains, this.domainIndex, { input_nodes: 0, number_cuts: new Map() }, 1, this.limits);
+        const memoKey = stableJson(predicate);
+        const cached = this.compiled.get(memoKey);
+        if (cached) {
+            this.compileCacheHits += 1;
+            return cached;
+        }
+        const rootId = this.builder.predicate(predicate, this.domainIndex);
+        const canonicalDag = this.builder.canonicalize(rootId);
+        const canonicalJson = stableJson(canonicalDag);
+        const canonicalBytes = Buffer.byteLength(canonicalJson, "utf8");
+        checkCanonicalBytes(canonicalBytes, this.limits.max_canonical_bytes);
+        const partitionEdges = canonicalDag.nodes.reduce((total, node) => total + node.edges.length, 0);
+        const referencedAxisRefs = [
+            ...new Set(canonicalDag.nodes.map((node) => node.axis_ref)),
+        ].sort(compareText);
+        const referenced = new Set(referencedAxisRefs);
+        const result = {
+            canonical_dag: canonicalDag,
+            canonical_sha256: sha256(canonicalJson),
+            canonical_bytes: canonicalBytes,
+            referenced_axis_refs: referencedAxisRefs,
+            omitted_axis_refs: this.domains
+                .map((domain) => domain.key)
+                .filter((axisRef) => !referenced.has(axisRef)),
+            theoretical_ground_cardinality: this.theoreticalGroundCardinality,
+            metrics: {
+                input_predicate_nodes: inspection.input_nodes,
+                canonical_dag_nodes: canonicalDag.nodes.length,
+                partition_edges: partitionEdges,
+                canonical_bytes: canonicalBytes,
+            },
+        };
+        this.compiled.set(memoKey, result);
+        return result;
+    }
+    statistics() {
+        return {
+            axis_partition_builds: 1,
+            compile_requests: this.compileRequests,
+            compile_cache_hits: this.compileCacheHits,
+            unique_compiled_predicates: this.compiled.size,
+        };
+    }
+    inspect(predicate) {
+        const inspection = {
+            input_nodes: 0,
+            number_cuts: new Map(),
+        };
+        validateSymbolicPredicate(predicate, this.domains, this.domainIndex, inspection, 1, this.limits);
+        return inspection;
+    }
+}
+export function createSymbolicDenotationCompilationSession(domains, seedPredicates, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+    return new SymbolicDenotationCompilationSession(domains, seedPredicates, limits);
+}
+function mergeNumberCuts(target, source) {
+    for (const [axisRef, cuts] of source) {
+        const values = target.get(axisRef) ?? new Set();
+        cuts.forEach((cut) => values.add(cut));
+        target.set(axisRef, values);
+    }
+}
+function assertKnownNumberCuts(known, actual) {
+    for (const [axisRef, cuts] of actual)
+        for (const cut of cuts)
+            if (!known.get(axisRef)?.has(cut))
+                invalid("compilation_session_axis_partition_stale", `${axisRef}:${cut}`);
+}
+function checkCanonicalBytes(actual, limit) {
+    if (actual > limit)
+        invalid("canonical_byte_limit_exceeded", `actual=${actual}:limit=${limit}`);
+}
+export function evaluateCanonicalSymbolicDenotation(dag, assignment) {
+    const nodes = new Map(dag.nodes.map((node) => [node.key, node]));
+    let current = dag.root_ref;
+    const visited = new Set();
+    while (current !== "terminal.true" && current !== "terminal.false") {
+        if (visited.has(current))
+            invalid("canonical_dag_cycle", current);
+        visited.add(current);
+        const node = nodes.get(current);
+        if (!node)
+            invalid("canonical_dag_node_unknown", current);
+        const value = assignment[node.axis_ref];
+        if (value === undefined)
+            invalid("canonical_dag_assignment_missing", node.axis_ref);
+        const matches = node.edges.filter((edge) => symbolicEdgeMatches(edge, value));
+        if (matches.length !== 1)
+            invalid("canonical_dag_assignment_partition_invalid", `${node.axis_ref}:matches=${matches.length}`);
+        current = matches[0].child_ref;
+    }
+    return current === "terminal.true";
+}
+void DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.symbolic_denotation_efficiency_delivery;

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

@@ -0,0 +1,11 @@
+import { denoteDesignResourceSymbolicPoint } from "./design-resource-symbolic-denotation.js";
+import { compileSymbolicDenotation, evaluateCanonicalSymbolicDenotation } from "./symbolic-denotation-engine.js";
+export declare const symbolicDenotation: Readonly<{
+    compile: typeof compileSymbolicDenotation;
+    evaluate: typeof evaluateCanonicalSymbolicDenotation;
+    denoteDesignPoint: typeof denoteDesignResourceSymbolicPoint;
+    sourceIr: Readonly<{
+        mediaType: "application/vnd.ty-context.symbolic-source-ir+json";
+        schemaVersion: "design-resource-symbolic-source-ir-v1";
+    }>;
+}>;

package/dist/lib/symbolic-denotation-public.js

@@ -0,0 +1,12 @@
+import { denoteDesignResourceSymbolicPoint } from "./design-resource-symbolic-denotation.js";
+import { compileSymbolicDenotation, evaluateCanonicalSymbolicDenotation, } from "./symbolic-denotation-engine.js";
+import { DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE, DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_SCHEMA_VERSION, } from "./design-resource-symbolic-source-ir-types.js";
+export const symbolicDenotation = Object.freeze({
+    compile: compileSymbolicDenotation,
+    evaluate: evaluateCanonicalSymbolicDenotation,
+    denoteDesignPoint: denoteDesignResourceSymbolicPoint,
+    sourceIr: Object.freeze({
+        mediaType: DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE,
+        schemaVersion: DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_SCHEMA_VERSION,
+    }),
+});

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

@@ -0,0 +1,20 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationCanonicalEdgeV1, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+interface EnumSegment {
+    kind: "enum";
+    values: string[];
+}
+interface NumberSegment {
+    kind: "number";
+    minimum: number;
+    maximum: number;
+}
+export type SymbolicAxisSegment = EnumSegment | NumberSegment;
+export interface SymbolicRuntimeAxis {
+    domain: SymbolicDenotationAxisDomain;
+    segments: SymbolicAxisSegment[];
+}
+export declare function buildSymbolicRuntimeAxes(domains: SymbolicDenotationAxisDomain[], numberCuts: ReadonlyMap<string, Set<number>>): SymbolicRuntimeAxis[];
+export declare function canonicalSymbolicEdges(axis: SymbolicRuntimeAxis, childRefs: string[]): SymbolicDenotationCanonicalEdgeV1[];
+export declare function symbolicEdgeMatches(edge: SymbolicDenotationCanonicalEdgeV1, value: SymbolicDenotationScalar): boolean;
+export declare function symbolicSegmentMatches(segment: SymbolicAxisSegment, matches: (value: SymbolicDenotationScalar) => boolean): boolean;
+export {};