@metamesh/modeling 0.18.0 → 0.19.0

package/dist/engine/session/graph.js

@@ -1,332 +1,309 @@
 import { GeometryError } from "../../geometry/errors.js";
 import { captureDiagnosticPath } from "../../model/diagnostic-path.js";
 import { GenerationError, } from "../../model/generation.js";
-import { captureGenerationDependencies, captureGenerationValue, compareGenerationValues, generationDataEntries, isImmutableGenerationValue, } from "../../model/immutable-generation-data.js";
+import { captureGenerationArguments, captureGenerationValue, compareGenerationValues, generationDataEntries, generationValueBytes, isImmutableGenerationValue, } from "../../model/immutable-generation-data.js";
 import { assertSynchronousScopeResult } from "../native/ownership.js";
-import { createModelDependencies } from "./dependencies.js";
-function reusableEntry(node) {
-    if (node.state.kind === "ready")
-        return node.state.entry;
-    if (node.state.kind === "pending")
-        return node.previous;
-    return undefined;
-}
-const parameterKeys = Symbol("parameter-keys");
-const emptyInputs = Object.freeze([]);
-const isArray = (value) => Array.isArray(value);
+import { createMemoProvenance } from "./dependencies.js";
+const maxEntries = 100_000;
+const maxVersions = 8;
+const source = Symbol("params-source"), contextSource = Symbol("model-context-source"), keys = Symbol("parameter-keys"), negativeZero = Symbol("negative-zero");
 const canonicalId = (id) => typeof id === "string" && id.length <= 64 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id);
 function invalid(message) {
-    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "generate" });
-}
-const sameInputs = (left, right) => left.length === right.length && left.every((value, index) => Object.is(value, right[index]));
-function evaluateComputed(callback) {
-    const result = callback();
-    assertSynchronousScopeResult(result, () => new GeometryError("INVALID_ARGUMENT", "Computed callbacks must be synchronous.", {
-        operation: "computed",
-    }));
-    return captureGenerationValue(result);
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "memo" });
 }
-/** Reuse immutable captures only when the host supplies the same input value. */
-function captureParameters(input, previousInput, previousSnapshot) {
-    return Object.freeze(Object.fromEntries(Array.from(generationDataEntries(input), ([key, value]) => {
-        if (Object.is(value, previousInput[key]) &&
-            Object.hasOwn(previousSnapshot, key) &&
-            isImmutableGenerationValue(value))
-            return [key, previousSnapshot[key]];
-        return [key, captureGenerationValue(value)];
-    })));
-}
-/**
- * Owns one revision's lazy computations and dynamic read sets. A failed read stays failed for the
- * attempt; only the surrounding generation revision can promote successful entries to the cache.
- */
-class ComputationRevision {
-    options;
-    parameterSnapshot;
-    committed;
-    readerIds;
-    validatedInputs;
-    assertActive;
-    assertNoFailedAssertion;
-    nodes = new Map();
-    keySignature;
-    stack = [];
-    constructor(options, parameterSnapshot, committed, readerIds, validatedInputs, assertActive, assertNoFailedAssertion) {
-        this.options = options;
-        this.parameterSnapshot = parameterSnapshot;
-        this.committed = committed;
-        this.readerIds = readerIds;
-        this.validatedInputs = validatedInputs;
-        this.assertActive = assertActive;
-        this.assertNoFailedAssertion = assertNoFailedAssertion;
-        // Structural reads share one unambiguous signature, even when parameter names contain NUL.
-        this.keySignature = JSON.stringify(Object.keys(parameterSnapshot));
-    }
-    get evaluating() {
-        return this.stack.length > 0;
-    }
-    currentEvaluation() {
-        const current = this.stack.at(-1);
-        if (current === undefined)
+function locate(index, fn, inputs, create = false) {
+    let node = index.get(fn);
+    if (node === undefined && create)
+        index.set(fn, (node = { children: new Map() }));
+    for (const input of inputs) {
+        if (node === undefined)
             return undefined;
-        const state = this.nodes.get(current)?.state;
-        return state?.kind === "evaluating" ? state : undefined;
-    }
-    dispose() {
-        // Retained numerical callbacks may keep an expired parameter guard alive. That guard must
-        // not retain unrelated callbacks or chain together every previous computation cache.
-        this.nodes.clear();
-        this.committed = new Map();
-    }
-    register(id, callback, dependencies = emptyInputs) {
-        if (!canonicalId(id) || this.nodes.has(id))
-            invalid("Computed IDs must be unique canonical lowercase identifiers of at most 64 characters.");
-        if (this.nodes.size >= 100_000)
-            throw new GeometryError("COMPLEXITY_LIMIT", "Too many declared computations.", {
-                operation: "computed",
-            });
-        if (typeof callback !== "function" || !Array.isArray(dependencies))
-            invalid("Use computed(id, callback, dependencies?) with an optional dependency array.");
-        const inputs = dependencies === emptyInputs
-            ? emptyInputs
-            : captureGenerationDependencies(dependencies, (value) => this.readerIds.has(value), this.validatedInputs);
-        const previous = this.committed.get(id);
-        this.nodes.set(id, {
-            callback,
-            inputs,
-            previous,
-            state: { kind: "pending" },
-        });
-    }
-    /** A handled dependency failure must still prevent the caller's fallback from becoming reusable. */
-    read = (id) => {
-        this.assertActive();
-        const parent = this.currentEvaluation();
-        try {
-            const node = this.nodes.get(id);
-            if (node === undefined)
-                invalid(`Computed '${id}' must be declared before it is read.`);
-            const cycle = this.stack.indexOf(id);
-            if (cycle >= 0)
-                invalid(`Computed dependency cycle: ${[...this.stack.slice(cycle), id].join(" -> ")}.`);
-            if (node.state.kind === "failed")
-                throw node.state.error;
-            const entry = node.state.kind === "ready" ? node.state.entry : this.evaluateNode(id, node);
-            if (parent !== undefined) {
-                parent.dependencies.set(id, entry.token);
-                if (!entry.cacheable)
-                    parent.cacheable = false;
-            }
-            return entry.value;
-        }
-        catch (error) {
-            if (parent !== undefined)
-                parent.cacheable = false;
-            throw error;
-        }
-    };
-    /** Validate old reads, evaluate or reuse the output, and publish exactly one local outcome. */
-    evaluateNode(id, node) {
-        const evaluation = {
-            kind: "evaluating",
-            parameters: new Map(),
-            dependencies: new Map(),
-            cacheable: true,
-        };
-        node.state = evaluation;
-        this.stack.push(id);
-        try {
-            const previous = node.previous;
-            const reusable = previous !== undefined && this.canReuse(node, previous);
-            let entry;
-            if (reusable && this.options.verifyCache !== true) {
-                entry = evaluation.cacheable ? previous : Object.freeze({ ...previous, cacheable: false });
-            }
-            else {
-                entry = this.evaluateCallback(id, node, evaluation, reusable);
-            }
-            node.state = { kind: "ready", entry };
-            return entry;
-        }
-        catch (error) {
-            // Neither partial dependencies nor an earlier value may escape a failed evaluation.
-            node.state = { kind: "failed", error };
-            throw error;
-        }
-        finally {
-            this.stack.pop();
-        }
-    }
-    canReuse(node, previous) {
-        if (this.options.cache === false || !sameInputs(node.inputs, previous.inputs))
-            return false;
-        for (const [key, value] of previous.parameters) {
-            const current = key === parameterKeys ? this.keySignature : Reflect.get(this.parameterSnapshot, key);
-            if (!Object.is(current, value))
-                return false;
-        }
-        for (const [dependency, token] of previous.dependencies) {
-            if (!this.nodes.has(dependency))
-                return false;
-            try {
-                this.read(dependency);
-            }
-            catch {
-                // Let the callback decide whether a failed dependency propagates or uses a fallback.
-                return false;
-            }
-            const state = this.nodes.get(dependency).state;
-            if (state.kind !== "ready" || state.entry.token !== token)
-                return false;
-        }
-        return true;
-    }
-    evaluateCallback(id, node, evaluation, reusable) {
-        // Validation may read old branches. Only callback reads describe the successful output,
-        // whether this is a cache miss or a development verification.
-        evaluation.parameters.clear();
-        evaluation.dependencies.clear();
-        evaluation.cacheable = true;
-        // Declared readers depend on their output, not just their stable callable identity.
-        for (const input of node.inputs) {
-            const dependency = typeof input === "function" ? this.readerIds.get(input) : undefined;
-            if (dependency !== undefined) {
-                try {
-                    this.read(dependency);
-                }
-                catch {
-                    // Failed reads already prevent reuse; the callback owns propagation or fallback.
-                }
-            }
-        }
-        const result = evaluateComputed(node.callback);
-        this.assertNoFailedAssertion();
-        const previous = node.previous;
-        let value = result;
-        if (reusable && previous !== undefined) {
-            const comparison = compareGenerationValues(previous.value, result);
-            if (comparison === "different")
-                invalid(`Cache verification for '${id}' found a changed result without a tracked dependency. Add changing outer values to the dependency array.`);
-            if (comparison === "unsupported")
-                invalid(`Cache verification for '${id}' cannot compare this result within its bounded data/recipe probe. Use cache: false for a full output equivalence check.`);
-            value = previous.value;
-        }
-        return Object.freeze({
-            inputs: node.inputs,
-            parameters: evaluation.parameters,
-            dependencies: evaluation.dependencies,
-            value,
-            cacheable: evaluation.cacheable,
-            // Tokens identify successful outputs, including new registrations of removed IDs. A per-node
-            // counter could repeat an old dependency's version and serve stale data.
-            token: previous !== undefined && Object.is(previous.value, value) ? previous.token : {},
-        });
+        const key = Object.is(input, -0) ? negativeZero : input;
+        let child = node.children.get(key);
+        if (child === undefined && create)
+            node.children.set(key, (child = { children: new Map() }));
+        node = child;
     }
+    return node;
+}
+/** Conservative map/trie bookkeeping, including read keys; calculated once per successful entry. */
+function entryOverhead(inputs, parameters) {
+    let bytes = 192 + inputs.length * 128;
+    for (const key of parameters.keys())
+        bytes += 48 + (typeof key === "string" ? key.length * 2 : 8);
+    return bytes;
+}
+function captureParameters(input, previous, snapshot) {
+    return Object.freeze(Object.fromEntries(Array.from(generationDataEntries(input), ([key, value]) => [
+        key,
+        Object.is(value, previous[key]) &&
+            Object.hasOwn(snapshot, key) &&
+            isImmutableGenerationValue(value)
+            ? snapshot[key]
+            : captureGenerationValue(value),
+    ])));
 }
-/** Owns computed identities and per-revision reads; the session commits only successful revisions. */
+/** Owns bounded successful memo histories and provisional per-revision evaluation. */
 export function createGenerationGraph(options, maxParts) {
-    let committed = new Map();
-    const readers = new Map();
-    const readerIds = new WeakMap();
-    const validatedInputs = new WeakSet();
-    let activeRead;
-    let previousInput = {};
-    let previousParameterSnapshot = {};
-    // Build stable readers outside registration's lexical scope so they cannot retain a revision's
-    // callback, captured locals, or dependency inputs after that revision closes.
-    const createReader = (id) => (() => {
-        if (activeRead === undefined)
-            return invalid("Computed readers can only be used during their active model session revision.");
-        return activeRead(id);
-    });
+    let committed = new WeakMap();
+    let retained = [];
+    let clock = 0;
+    let previousInput = {}, previousSnapshot = {};
+    const validated = new WeakSet();
+    const provenance = createMemoProvenance();
     return {
         begin(input, checkReactiveRead) {
-            let active = true;
-            let declaring = true;
-            let assertionFailure;
-            const diagnostics = [];
-            const partIds = new Set();
-            const declaredParts = new WeakSet();
-            const modelParameters = new Set();
+            let active = true, declaring = true, assertionFailure;
+            let checkAccess = checkReactiveRead, previousEntries = committed, pending = new WeakMap();
+            let previousRetained = retained, revisionClock = clock, selected;
             const inputValues = input;
-            const parameterSnapshot = captureParameters(inputValues, previousInput, previousParameterSnapshot);
+            const snapshot = captureParameters(inputValues, previousInput, previousSnapshot);
+            const keySignature = JSON.stringify(Object.keys(snapshot));
+            const stack = [], calls = [], diagnostics = [];
+            let boundContext;
+            const completed = [];
+            const reported = new WeakSet();
+            const declaredParts = new WeakSet(), partIds = new Set(), outerReads = new Set();
             const assertActive = () => {
                 if (!active)
                     invalid("The generation context has expired.");
-                checkReactiveRead();
+                checkAccess();
             };
             const assertNoFailedAssertion = () => {
                 if (assertionFailure !== undefined)
                     throw assertionFailure;
             };
-            const computations = new ComputationRevision(options, parameterSnapshot, committed, readerIds, validatedInputs, assertActive, assertNoFailedAssertion);
-            const params = new Proxy(parameterSnapshot, {
-                get: (target, key) => {
+            const record = (key, value) => {
+                if (stack.length !== 0)
+                    for (const current of stack)
+                        current.parameters.set(key, value);
+                else if (typeof key === "string")
+                    outerReads.add(key);
+            };
+            const publish = (entry, node) => {
+                if (!reported.has(node)) {
+                    reported.add(node);
+                    completed.push({
+                        id: `memo-${completed.length + 1}`,
+                        inputs: entry.inputs,
+                        parameters: entry.parameters,
+                        value: entry.value,
+                    });
+                }
+                for (const parent of stack) {
+                    for (const [key, value] of entry.parameters)
+                        parent.parameters.set(key, value);
+                    if (!entry.cacheable)
+                        parent.cacheable = false;
+                }
+                return entry.value;
+            };
+            const roots = (entries) => [
+                snapshot,
+                inputValues,
+                ...entries.flatMap((entry) => [entry, ...entry.entry.parameters.values()]),
+            ];
+            // Current tuples take priority. Unused successful tuples stay ordered by last use;
+            // weak callable keys allow collected functions to be pruned on later revisions.
+            const prepareRetention = (extra, ceiling) => {
+                const current = [];
+                for (const { fn, inputs, node } of calls)
+                    if (node.state?.kind === "ready" && node.state.entry.cacheable)
+                        current.push({
+                            fn: new WeakRef(fn),
+                            inputs,
+                            entry: node.state.entry,
+                            usedAt: node.usedAt,
+                        });
+                current.sort((left, right) => right.usedAt - left.usedAt);
+                const dormant = [];
+                if (options.cache !== false)
+                    for (const entry of previousRetained) {
+                        const fn = entry.fn.deref();
+                        if (fn === undefined)
+                            continue;
+                        const touched = locate(pending, fn, entry.inputs)?.state;
+                        if (touched?.kind === "failed" ||
+                            (touched?.kind === "ready" &&
+                                (!touched.entry.cacheable || sameReads(touched.entry, entry.entry))))
+                            continue;
+                        dormant.push(entry);
+                    }
+                const candidates = [];
+                const overhead = [0];
+                // The trie interns validated argument tuples, so their immutable array identity is a
+                // stable bucket key across parameter versions. Keep only the newest bounded history.
+                const versions = new Map();
+                if (options.cache !== false)
+                    for (const entry of [...current, ...dormant]) {
+                        const count = versions.get(entry.inputs) ?? 0;
+                        if (count >= maxVersions)
+                            continue;
+                        versions.set(entry.inputs, count + 1);
+                        candidates.push(entry);
+                        overhead.push(overhead.at(-1) + entry.entry.overheadBytes);
+                        if (candidates.length >= maxEntries)
+                            break;
+                    }
+                const cost = (count) => overhead[count] +
+                    generationValueBytes([...roots(candidates.slice(0, count)), ...extra], ceiling - overhead[count]);
+                const fullCost = cost(candidates.length);
+                if (fullCost <= ceiling) {
+                    selected = candidates;
+                    return fullCost;
+                }
+                else {
+                    // Prefix search preserves priority while using logarithmic budget probes rather
+                    // than repeatedly walking a progressively shortened large cache one entry at a time.
+                    let low = 0, high = candidates.length;
+                    let selectedCost = cost(0);
+                    if (selectedCost > ceiling) {
+                        selected = [];
+                        return selectedCost;
+                    }
+                    while (low < high) {
+                        const middle = Math.ceil((low + high) / 2);
+                        const bytes = cost(middle);
+                        if (bytes <= ceiling) {
+                            low = middle;
+                            selectedCost = bytes;
+                        }
+                        else
+                            high = middle - 1;
+                    }
+                    selected = candidates.slice(0, low);
+                    return selectedCost;
+                }
+            };
+            const retainedEntries = () => {
+                if (selected === undefined)
+                    prepareRetention([], Infinity);
+                return selected;
+            };
+            const sameReads = (left, right) => left === right ||
+                (left.parameters.size === right.parameters.size &&
+                    [...left.parameters].every(([key, value]) => right.parameters.has(key) && Object.is(value, right.parameters.get(key))));
+            // One snapshot-backed proxy is shared by outer generation and every call. It is NEVER
+            // redirected to another revision, so identity/aliasing within a call remain ordinary JS.
+            const params = new Proxy(snapshot, {
+                get(target, key) {
                     assertActive();
                     const value = Reflect.get(target, key);
-                    const current = computations.currentEvaluation();
-                    if (current !== undefined && typeof key === "string")
-                        current.parameters.set(key, value);
-                    else if (typeof key === "string" && Object.hasOwn(target, key))
-                        modelParameters.add(key);
+                    if (typeof key === "string")
+                        record(key, value);
                     return value;
                 },
                 set: () => invalid("Parameters are immutable."),
                 deleteProperty: () => invalid("Parameters are immutable."),
-                ownKeys: (target) => {
+                ownKeys(target) {
                     assertActive();
-                    const current = computations.currentEvaluation();
-                    if (current !== undefined)
-                        current.parameters.set(parameterKeys, computations.keySignature);
-                    else
-                        for (const key of Object.keys(target))
-                            modelParameters.add(key);
+                    record(keys, keySignature);
                     return Reflect.ownKeys(target);
                 },
-                has: (target, key) => {
+                has(target, key) {
                     assertActive();
-                    const current = computations.currentEvaluation();
-                    if (current !== undefined)
-                        current.parameters.set(parameterKeys, computations.keySignature);
-                    else if (typeof key === "string")
-                        modelParameters.add(key);
+                    record(keys, keySignature);
                     return Reflect.has(target, key);
                 },
-                getOwnPropertyDescriptor: (target, key) => {
+                getOwnPropertyDescriptor(target, key) {
                     assertActive();
+                    record(keys, keySignature);
                     const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-                    const current = computations.currentEvaluation();
-                    if (current !== undefined) {
-                        const dependencies = current.parameters;
-                        dependencies.set(parameterKeys, computations.keySignature);
-                        if (typeof key === "string")
-                            dependencies.set(key, descriptor?.value);
-                    }
-                    else if (typeof key === "string")
-                        modelParameters.add(key);
+                    if (typeof key === "string")
+                        record(key, descriptor?.value);
                     return descriptor;
                 },
             });
-            activeRead = computations.read;
-            const computed = ((id, callback, dependencies) => {
+            const memo = ((fn, ...args) => {
                 assertActive();
-                if (!declaring || computations.evaluating)
-                    invalid("Declare computations only in the outer generation callback.");
-                computations.register(id, callback, dependencies);
-                let reader = readers.get(id);
-                if (reader === undefined) {
-                    reader = createReader(id);
-                    readers.set(id, reader);
-                    readerIds.set(reader, id);
+                const parent = stack.at(-1);
+                try {
+                    if (!declaring || typeof fn !== "function")
+                        invalid("Use memo(fn, ...args) during generation.");
+                    // Normal immutable args compare by identity. Only the explicitly passed current params
+                    // object is keyed by source + observed field values instead of revision proxy identity.
+                    const normalized = args.map((arg) => arg === params
+                        ? source
+                        : arg === boundContext && boundContext !== undefined
+                            ? contextSource
+                            : arg);
+                    const known = locate(pending, fn, normalized);
+                    const history = options.cache === false ? undefined : locate(previousEntries, fn, normalized)?.history;
+                    // A hit names the same already-validated immutable argument identities. Only a
+                    // genuinely new tuple needs another deep validation/capture traversal.
+                    const inputs = known?.state?.kind === "ready"
+                        ? known.state.entry.inputs
+                        : history !== undefined && history.length !== 0
+                            ? history[0].inputs
+                            : captureGenerationArguments(normalized, validated);
+                    if (known === undefined && calls.length >= maxEntries)
+                        throw new GeometryError("COMPLEXITY_LIMIT", "Too many memo calls.");
+                    const node = known ?? locate(pending, fn, inputs, true);
+                    node.usedAt = ++revisionClock;
+                    selected = undefined;
+                    if (node.state?.kind === "evaluating")
+                        invalid("Memo dependency cycle.");
+                    if (node.state?.kind === "failed")
+                        throw node.state.error;
+                    if (node.state?.kind === "ready") {
+                        return publish(node.state.entry, node);
+                    }
+                    calls.push({ fn, inputs, node });
+                    const previous = history?.find((entry) => [...entry.parameters].every(([key, value]) => Object.is(value, key === keys ? keySignature : Reflect.get(snapshot, key))));
+                    if (previous !== undefined && options.verifyCache !== true) {
+                        node.state = { kind: "ready", entry: previous };
+                        return publish(previous, node);
+                    }
+                    const evaluation = {
+                        kind: "evaluating",
+                        parameters: new Map(),
+                        cacheable: true,
+                    };
+                    node.state = evaluation;
+                    stack.push(evaluation);
+                    try {
+                        const result = Reflect.apply(fn, undefined, args);
+                        assertSynchronousScopeResult(result, () => new GeometryError("INVALID_ARGUMENT", "Memo functions must be synchronous."));
+                        assertNoFailedAssertion();
+                        // Capture is inside the tracked scope: returning/spreading params records all fields.
+                        let value = captureGenerationValue(result);
+                        if (previous !== undefined) {
+                            const comparison = compareGenerationValues(previous.value, value);
+                            if (comparison !== "equal")
+                                invalid(comparison === "different"
+                                    ? "Memo verification found changed output for unchanged inputs."
+                                    : "Memo verification cannot compare this output within its bounded probe.");
+                            value = previous.value;
+                        }
+                        const entry = Object.freeze({
+                            inputs,
+                            parameters: evaluation.parameters,
+                            value,
+                            cacheable: evaluation.cacheable,
+                            overheadBytes: entryOverhead(inputs, evaluation.parameters),
+                        });
+                        node.state = { kind: "ready", entry };
+                        return publish(entry, node);
+                    }
+                    catch (error) {
+                        node.state = { kind: "failed", error };
+                        throw error;
+                    }
+                    finally {
+                        stack.pop();
+                    }
+                }
+                catch (error) {
+                    if (parent !== undefined)
+                        parent.cacheable = false;
+                    throw error;
                 }
-                return reader;
             });
             const issue = (severity, message, metadata) => {
                 assertActive();
                 if (typeof message !== "string" || message.length === 0)
                     invalid("Diagnostics require a nonempty message.");
-                if (metadata?.parameterId !== undefined &&
-                    !Object.hasOwn(parameterSnapshot, metadata.parameterId))
+                if (metadata?.parameterId !== undefined && !Object.hasOwn(snapshot, metadata.parameterId))
                     invalid("Diagnostic parameterId must name an existing parameter.");
                 diagnostics.push(Object.freeze({
                     severity,
@@ -341,19 +318,18 @@ export function createGenerationGraph(options, maxParts) {
             };
             const part = ((id, value) => {
                 assertActive();
-                if (!declaring || computations.evaluating)
-                    invalid("Declare parts only in the outer generation callback.");
+                if (!declaring || stack.length !== 0)
+                    invalid("Declare parts only in outer generation.");
                 if (!canonicalId(id) || partIds.has(id))
-                    invalid("Part IDs must be unique canonical lowercase identifiers of at most 64 characters.");
+                    invalid("Part IDs must be unique canonical identifiers.");
                 partIds.add(id);
                 const configuration = typeof value === "object" && value !== null && "geometry" in value
                     ? value
                     : { geometry: value };
                 if ("position" in configuration || "rotation" in configuration)
-                    invalid("Part placement uses transform; position and rotation are not supported.");
-                for (const value of [configuration.geometry, configuration.transform])
-                    if (typeof value === "function" && !readerIds.has(value))
-                        invalid("Part readers must belong to this model session.");
+                    invalid("Part placement uses transform.");
+                if ([configuration.geometry, configuration.transform].some((item) => typeof item === "function"))
+                    invalid("Parts require ordinary geometry and transform values.");
                 const descriptor = Object.freeze({ ...configuration, id });
                 declaredParts.add(descriptor);
                 return descriptor;
@@ -365,87 +341,88 @@ export function createGenerationGraph(options, maxParts) {
                 if (!condition)
                     issue("error", message, metadata);
             }
+            const context = {
+                params,
+                memo,
+                part,
+                assert,
+                warn: (message, metadata) => {
+                    if (!declaring || stack.length !== 0)
+                        invalid("Warnings must be emitted in outer generation.");
+                    issue("warning", message, metadata);
+                },
+            };
             return {
-                context: {
-                    params,
-                    computed,
-                    part,
-                    assert,
-                    warn: (message, metadata) => {
-                        if (!declaring || computations.evaluating)
-                            invalid("Warnings must be emitted in the outer generation callback.");
-                        issue("warning", message, metadata);
-                    },
+                context,
+                withServices(services) {
+                    const supplied = Object.freeze({ ...context, services });
+                    boundContext = supplied;
+                    return supplied;
                 },
                 assertActive,
                 diagnostics,
                 finish(output) {
-                    assertSynchronousScopeResult(output, () => new GeometryError("INVALID_ARGUMENT", "Generation callbacks must be synchronous.", {
-                        operation: "generate",
-                    }));
-                    // Catching an assertion does not turn its revision into a successful snapshot.
+                    assertSynchronousScopeResult(output, () => new GeometryError("INVALID_ARGUMENT", "Generation callbacks must be synchronous."));
                     assertNoFailedAssertion();
                     declaring = false;
-                    const parts = isArray(output) ? output : [output];
+                    const parts = Array.isArray(output)
+                        ? output
+                        : [output];
                     if (parts.length === 0)
                         invalid("Generation must return at least one declared part.");
                     if (parts.length > maxParts)
-                        throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${maxParts} parts.`, {
-                            operation: "generate",
-                        });
-                    const returnedIds = new Set();
+                        throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${maxParts} parts.`);
+                    const ids = new Set();
                     for (const descriptor of parts) {
-                        if (!declaredParts.has(descriptor) || returnedIds.has(descriptor.id))
+                        if (!declaredParts.has(descriptor) || ids.has(descriptor.id))
                             invalid("Return each declared output part at most once.");
-                        returnedIds.add(descriptor.id);
+                        ids.add(descriptor.id);
                     }
                     return parts;
                 },
                 dependencies(output) {
-                    return createModelDependencies(output, modelParameters, new Map([...computations.nodes].map(([id, node]) => [id, reusableEntry(node)])), readerIds);
-                },
-                computedValues() {
-                    return [...computations.nodes.values()].map((node) => reusableEntry(node)?.value);
+                    return provenance(output, outerReads, completed);
                 },
-                retainedValues() {
-                    const retained = [];
-                    for (const node of computations.nodes.values()) {
-                        const entry = reusableEntry(node);
-                        if (entry !== undefined)
-                            retained.push(entry.value, entry.inputs, ...entry.parameters.values());
-                    }
-                    return [...retained, parameterSnapshot, inputValues];
+                prepareRetention,
+                memoValues() {
+                    return retainedEntries().map((entry) => entry.entry.value);
                 },
                 commit() {
-                    const accepted = new Map();
-                    for (const [id, node] of computations.nodes) {
-                        const entry = reusableEntry(node);
-                        if (entry?.cacheable)
-                            accepted.set(id, entry);
+                    const next = new WeakMap();
+                    const accepted = [];
+                    for (const entry of retainedEntries()) {
+                        const fn = entry.fn.deref();
+                        if (fn === undefined)
+                            continue;
+                        const bucket = locate(next, fn, entry.inputs, true);
+                        (bucket.history ??= []).push(entry.entry);
+                        accepted.push(entry);
                     }
-                    committed = accepted;
+                    committed = next;
+                    retained = accepted;
+                    clock = revisionClock;
                     previousInput = { ...inputValues };
-                    previousParameterSnapshot = parameterSnapshot;
-                    for (const id of readers.keys())
-                        if (!computations.nodes.has(id))
-                            readers.delete(id);
+                    previousSnapshot = snapshot;
                 },
                 close() {
                     active = false;
-                    activeRead = undefined;
-                    computations.dispose();
-                    // Failed edits and validation probes cannot retain newly registered readers.
-                    for (const id of readers.keys())
-                        if (!committed.has(id))
-                            readers.delete(id);
+                    calls.length = 0;
+                    pending = new WeakMap();
+                    previousEntries = new WeakMap();
+                    previousRetained = [];
+                    selected = [];
+                    completed.length = 0;
+                    checkAccess = () => { };
+                    boundContext = undefined;
                 },
             };
         },
         clear() {
-            committed.clear();
-            readers.clear();
+            committed = new WeakMap();
+            retained = [];
+            clock = 0;
             previousInput = {};
-            previousParameterSnapshot = {};
+            previousSnapshot = {};
         },
     };
 }