project-tiny-context-harness 0.11.0 → 0.12.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +0,0 @@
-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 {};