@metamesh/modeling 0.19.0 → 0.20.0

package/dist/engine/session/declarations.js

@@ -0,0 +1,98 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { captureDiagnosticPath } from "../../model/diagnostic-path.js";
+import { GenerationError, } from "../../model/generation.js";
+import { assertSynchronousScopeResult } from "../native/ownership.js";
+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: "memo" });
+}
+/** Owns one revision's parts and diagnostics; caught assertions remain fatal to that revision. */
+export function createGenerationDeclarations(options) {
+    const { assertActive, isMemoEvaluating, hasParameter } = options;
+    const diagnostics = [];
+    const declaredParts = new WeakSet();
+    const partIds = new Set();
+    let declaring = true;
+    let assertionFailure;
+    const assertNoFailedAssertion = () => {
+        if (assertionFailure !== undefined)
+            throw assertionFailure;
+    };
+    const issue = (severity, message, metadata) => {
+        assertActive();
+        if (typeof message !== "string" || message.length === 0)
+            invalid("Diagnostics require a nonempty message.");
+        if (metadata?.parameterId !== undefined && !hasParameter(metadata.parameterId))
+            invalid("Diagnostic parameterId must name an existing parameter.");
+        diagnostics.push(Object.freeze({
+            severity,
+            message,
+            ...(metadata?.parameterId === undefined ? {} : { parameterId: metadata.parameterId }),
+            ...(metadata?.path === undefined ? {} : { path: captureDiagnosticPath(metadata.path) }),
+        }));
+        if (severity === "error") {
+            // A model's catch block must not turn a failed assertion into a successful revision.
+            assertionFailure ??= new GenerationError(diagnostics);
+            throw assertionFailure;
+        }
+    };
+    const part = (id, value) => {
+        assertActive();
+        if (!declaring || isMemoEvaluating())
+            invalid("Declare parts only in outer generation.");
+        if (!canonicalId(id) || partIds.has(id))
+            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.");
+        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;
+    };
+    function assert(condition, message, metadata) {
+        assertActive();
+        if (typeof condition !== "boolean")
+            invalid("assert requires a boolean condition.");
+        if (!condition)
+            issue("error", message, metadata);
+    }
+    const warn = (message, metadata) => {
+        if (!declaring || isMemoEvaluating())
+            invalid("Warnings must be emitted in outer generation.");
+        issue("warning", message, metadata);
+    };
+    return {
+        part,
+        assert,
+        warn,
+        diagnostics: diagnostics,
+        get declaring() {
+            return declaring;
+        },
+        assertNoFailedAssertion,
+        finish(output) {
+            assertSynchronousScopeResult(output, () => new GeometryError("INVALID_ARGUMENT", "Generation callbacks must be synchronous."));
+            assertNoFailedAssertion();
+            declaring = false;
+            const parts = Array.isArray(output)
+                ? output
+                : [output];
+            if (parts.length === 0)
+                invalid("Generation must return at least one declared part.");
+            if (parts.length > options.maxParts)
+                throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${options.maxParts} parts.`);
+            const ids = new Set();
+            for (const descriptor of parts) {
+                if (!declaredParts.has(descriptor) || ids.has(descriptor.id))
+                    invalid("Return each declared output part at most once.");
+                ids.add(descriptor.id);
+            }
+            return parts;
+        },
+    };
+}

package/dist/engine/session/dependencies.js

@@ -14,46 +14,91 @@ function children(value, includeRecipeOperands = false) {
         return includeRecipeOperands ? recipe.call.args : [];
     return generationDataMetadata(value)?.children ?? Object.values(value);
 }
-/** Weak membership summaries avoid walking captured outline/grid graphs again on warm revisions. */
+/**
+ * Projects diagnostic provenance without participating in cache invalidation.
+ * Immutable membership summaries and their weak reverse index survive revisions; origin IDs do not.
+ */
 export function createMemoProvenance() {
     const summaries = new WeakMap();
-    const summarize = (root) => {
-        let summary = summaries.get(root);
+    const memberships = new WeakMap();
+    const summarize = (value) => {
+        let summary = summaries.get(value);
         if (summary !== undefined)
             return summary;
         summary = new WeakSet();
-        const visit = (value) => {
-            if (!objectValue(value) || summary.has(value))
-                return;
-            summary.add(value);
-            for (const child of children(value))
-                visit(child);
-        };
-        visit(root);
-        summaries.set(root, summary);
+        const reference = new WeakRef(summary);
+        const pending = [value];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            if (summary.has(current))
+                continue;
+            summary.add(current);
+            let membership = memberships.get(current);
+            if (membership === undefined) {
+                membership = { summaries: new Set(), compactAt: 16 };
+                memberships.set(current, membership);
+            }
+            // A surviving child must not retain its obsolete output containers. Weak references
+            // preserve warm summaries without keeping roots alive. Geometric compaction amortizes
+            // cleanup even when many live outputs share this child; queries also prune dead entries.
+            if (membership.summaries.size >= membership.compactAt) {
+                for (const known of membership.summaries)
+                    if (known.deref() === undefined)
+                        membership.summaries.delete(known);
+                membership.compactAt = Math.max(16, membership.summaries.size * 2);
+            }
+            membership.summaries.add(reference);
+            for (const child of children(current))
+                if (objectValue(child))
+                    pending.push(child);
+        }
+        summaries.set(value, summary);
         return summary;
     };
     return (output, modelParameters, calls) => {
-        const completed = [];
+        const origins = new Map();
+        const owners = (value) => {
+            const found = new Set();
+            const membership = memberships.get(value);
+            if (membership === undefined)
+                return found;
+            // Cached dormant outputs can outnumber this revision's calls. Probe the smaller index
+            // so a surviving shared child does not make current work proportional to cache history.
+            if (origins.size < membership.summaries.size) {
+                for (const [summary, ids] of origins)
+                    if (summary.has(value))
+                        for (const id of ids)
+                            found.add(id);
+                return found;
+            }
+            for (const reference of membership.summaries) {
+                const summary = reference.deref();
+                if (summary === undefined)
+                    membership.summaries.delete(reference);
+                else
+                    for (const id of origins.get(summary) ?? [])
+                        found.add(id);
+            }
+            return found;
+        };
         const transitive = new Map();
         const roots = (values) => {
             const found = new Set(), visited = new WeakSet();
-            const visit = (value) => {
+            const pending = [...values];
+            while (pending.length > 0) {
+                const value = pending.pop();
                 if (!objectValue(value) || visited.has(value))
-                    return;
+                    continue;
                 visited.add(value);
-                let owned = false;
-                for (const call of completed)
-                    if (call.members.has(value)) {
-                        found.add(call.id);
-                        owned = true;
-                    }
-                if (!owned)
+                const known = owners(value);
+                for (const id of known)
+                    found.add(id);
+                // Once an object has an origin, its owning calls supply transitive dependencies.
+                // Only unowned recipes expose operands; containing a recipe never claims its operands.
+                if (known.size === 0)
                     for (const child of children(value, true))
-                        visit(child);
-            };
-            for (const value of values)
-                visit(value);
+                        pending.push(child);
+            }
             return found;
         };
         const allParameters = (direct, dependencies) => {
@@ -64,13 +109,21 @@ export function createMemoProvenance() {
             return parameters;
         };
         const computations = calls.map((call) => {
+            // Publish this output's origin after reading its inputs: aliases can depend on earlier
+            // producers of the same value, while the current call cannot become its own dependency.
             const dependencies = roots(call.inputs);
             const parameters = [...call.parameters.keys()]
                 .filter((key) => typeof key === "string")
                 .sort();
             transitive.set(call.id, allParameters(parameters, dependencies));
-            if (objectValue(call.value))
-                completed.push({ id: call.id, members: summarize(call.value) });
+            if (objectValue(call.value)) {
+                const summary = summarize(call.value);
+                const known = origins.get(summary);
+                if (known === undefined)
+                    origins.set(summary, [call.id]);
+                else
+                    known.push(call.id);
+            }
             return Object.freeze({
                 id: call.id,
                 parameters: Object.freeze(parameters),

package/dist/engine/session/graph.js

@@ -1,13 +1,13 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { captureDiagnosticPath } from "../../model/diagnostic-path.js";
-import { GenerationError, } from "../../model/generation.js";
-import { captureGenerationArguments, captureGenerationValue, compareGenerationValues, generationDataEntries, generationValueBytes, isImmutableGenerationValue, } from "../../model/immutable-generation-data.js";
+import { resolveGeometryResolution } from "../../geometry/sampling/resolution.js";
+import { captureGenerationArguments, captureGenerationValue, compareGenerationValues, generationValueBytes, } from "../../model/immutable-generation-data.js";
 import { assertSynchronousScopeResult } from "../native/ownership.js";
+import { createGenerationDeclarations } from "./declarations.js";
 import { createMemoProvenance } from "./dependencies.js";
+import { createParameterSource } from "./parameters.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);
+const source = Symbol("params-source"), contextSource = Symbol("model-context-source"), negativeZero = Symbol("negative-zero");
 function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "memo" });
 }
@@ -33,46 +33,36 @@ function entryOverhead(inputs, parameters) {
         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 bounded successful memo histories and provisional per-revision evaluation. */
-export function createGenerationGraph(options, maxParts) {
+/**
+ * Owns bounded successful memo histories and provisional per-revision evaluation.
+ * begin() isolates the pending trie from committed history. Retention selects a priority-ordered
+ * prefix; only the session may commit it after native cleanup succeeds. Closing a revision drops
+ * its temporary references without changing the previously committed cache.
+ */
+export function createGenerationGraph(options, limits) {
+    const resolution = Object.freeze(resolveGeometryResolution({ ...options.resolution }, limits));
+    const effectiveLimits = Object.freeze({ ...limits });
     let committed = new WeakMap();
     let retained = [];
     let clock = 0;
-    let previousInput = {}, previousSnapshot = {};
+    const parameterSource = createParameterSource();
     const validated = new WeakSet();
     const provenance = createMemoProvenance();
     return {
         begin(input, checkReactiveRead) {
-            let active = true, declaring = true, assertionFailure;
+            let active = true;
             let checkAccess = checkReactiveRead, previousEntries = committed, pending = new WeakMap();
             let previousRetained = retained, revisionClock = clock, selected;
-            const inputValues = input;
-            const snapshot = captureParameters(inputValues, previousInput, previousSnapshot);
-            const keySignature = JSON.stringify(Object.keys(snapshot));
-            const stack = [], calls = [], diagnostics = [];
+            const stack = [], calls = [];
             let boundContext;
             const completed = [];
             const reported = new WeakSet();
-            const declaredParts = new WeakSet(), partIds = new Set(), outerReads = new Set();
+            const outerReads = new Set();
             const assertActive = () => {
                 if (!active)
                     invalid("The generation context has expired.");
                 checkAccess();
             };
-            const assertNoFailedAssertion = () => {
-                if (assertionFailure !== undefined)
-                    throw assertionFailure;
-            };
             const record = (key, value) => {
                 if (stack.length !== 0)
                     for (const current of stack)
@@ -80,6 +70,14 @@ export function createGenerationGraph(options, maxParts) {
                 else if (typeof key === "string")
                     outerReads.add(key);
             };
+            const parameters = parameterSource.begin(input, assertActive, record);
+            const { params } = parameters;
+            const declarations = createGenerationDeclarations({
+                maxParts: effectiveLimits.maxParts,
+                assertActive,
+                isMemoEvaluating: () => stack.length !== 0,
+                hasParameter: parameters.has,
+            });
             const publish = (entry, node) => {
                 if (!reported.has(node)) {
                     reported.add(node);
@@ -99,8 +97,7 @@ export function createGenerationGraph(options, maxParts) {
                 return entry.value;
             };
             const roots = (entries) => [
-                snapshot,
-                inputValues,
+                ...parameters.retainedValues,
                 ...entries.flatMap((entry) => [entry, ...entry.entry.parameters.values()]),
             ];
             // Current tuples take priority. Unused successful tuples stay ordered by last use;
@@ -183,42 +180,11 @@ export function createGenerationGraph(options, maxParts) {
             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);
-                    if (typeof key === "string")
-                        record(key, value);
-                    return value;
-                },
-                set: () => invalid("Parameters are immutable."),
-                deleteProperty: () => invalid("Parameters are immutable."),
-                ownKeys(target) {
-                    assertActive();
-                    record(keys, keySignature);
-                    return Reflect.ownKeys(target);
-                },
-                has(target, key) {
-                    assertActive();
-                    record(keys, keySignature);
-                    return Reflect.has(target, key);
-                },
-                getOwnPropertyDescriptor(target, key) {
-                    assertActive();
-                    record(keys, keySignature);
-                    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-                    if (typeof key === "string")
-                        record(key, descriptor?.value);
-                    return descriptor;
-                },
-            });
             const memo = ((fn, ...args) => {
                 assertActive();
                 const parent = stack.at(-1);
                 try {
-                    if (!declaring || typeof fn !== "function")
+                    if (!declarations.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.
@@ -249,7 +215,7 @@ export function createGenerationGraph(options, maxParts) {
                         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))));
+                    const previous = history?.find((entry) => [...entry.parameters].every(([key, value]) => Object.is(value, parameters.read(key))));
                     if (previous !== undefined && options.verifyCache !== true) {
                         node.state = { kind: "ready", entry: previous };
                         return publish(previous, node);
@@ -264,7 +230,7 @@ export function createGenerationGraph(options, maxParts) {
                     try {
                         const result = Reflect.apply(fn, undefined, args);
                         assertSynchronousScopeResult(result, () => new GeometryError("INVALID_ARGUMENT", "Memo functions must be synchronous."));
-                        assertNoFailedAssertion();
+                        declarations.assertNoFailedAssertion();
                         // Capture is inside the tracked scope: returning/spreading params records all fields.
                         let value = captureGenerationValue(result);
                         if (previous !== undefined) {
@@ -299,58 +265,14 @@ export function createGenerationGraph(options, maxParts) {
                     throw error;
                 }
             });
-            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(snapshot, metadata.parameterId))
-                    invalid("Diagnostic parameterId must name an existing parameter.");
-                diagnostics.push(Object.freeze({
-                    severity,
-                    message,
-                    ...(metadata?.parameterId === undefined ? {} : { parameterId: metadata.parameterId }),
-                    ...(metadata?.path === undefined ? {} : { path: captureDiagnosticPath(metadata.path) }),
-                }));
-                if (severity === "error") {
-                    assertionFailure ??= new GenerationError(diagnostics);
-                    throw assertionFailure;
-                }
-            };
-            const part = ((id, value) => {
-                assertActive();
-                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 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.");
-                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;
-            });
-            function assert(condition, message, metadata) {
-                assertActive();
-                if (typeof condition !== "boolean")
-                    invalid("assert requires a boolean condition.");
-                if (!condition)
-                    issue("error", message, metadata);
-            }
             const context = {
                 params,
+                resolution,
+                limits: effectiveLimits,
                 memo,
-                part,
-                assert,
-                warn: (message, metadata) => {
-                    if (!declaring || stack.length !== 0)
-                        invalid("Warnings must be emitted in outer generation.");
-                    issue("warning", message, metadata);
-                },
+                part: declarations.part,
+                assert: declarations.assert,
+                warn: declarations.warn,
             };
             return {
                 context,
@@ -360,26 +282,8 @@ export function createGenerationGraph(options, maxParts) {
                     return supplied;
                 },
                 assertActive,
-                diagnostics,
-                finish(output) {
-                    assertSynchronousScopeResult(output, () => new GeometryError("INVALID_ARGUMENT", "Generation callbacks must be synchronous."));
-                    assertNoFailedAssertion();
-                    declaring = false;
-                    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.`);
-                    const ids = new Set();
-                    for (const descriptor of parts) {
-                        if (!declaredParts.has(descriptor) || ids.has(descriptor.id))
-                            invalid("Return each declared output part at most once.");
-                        ids.add(descriptor.id);
-                    }
-                    return parts;
-                },
+                diagnostics: declarations.diagnostics,
+                finish: declarations.finish,
                 dependencies(output) {
                     return provenance(output, outerReads, completed);
                 },
@@ -401,8 +305,7 @@ export function createGenerationGraph(options, maxParts) {
                     committed = next;
                     retained = accepted;
                     clock = revisionClock;
-                    previousInput = { ...inputValues };
-                    previousSnapshot = snapshot;
+                    parameters.commit();
                 },
                 close() {
                     active = false;
@@ -421,8 +324,7 @@ export function createGenerationGraph(options, maxParts) {
             committed = new WeakMap();
             retained = [];
             clock = 0;
-            previousInput = {};
-            previousSnapshot = {};
+            parameterSource.clear();
         },
     };
 }

package/dist/engine/session/parameters.js

@@ -0,0 +1,78 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { captureGenerationValue, generationDataEntries, isImmutableGenerationValue, } from "../../model/immutable-generation-data.js";
+const keys = Symbol("parameter-keys");
+function immutable() {
+    throw new GeometryError("INVALID_ARGUMENT", "Parameters are immutable.", { operation: "memo" });
+}
+/** Captures supported data and reuses identities only when the entire caller graph is immutable. */
+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 committed parameter identities and creates a separate guarded snapshot for every revision.
+ * The session commits identities only after successful geometry finalization and native cleanup.
+ */
+export function createParameterSource() {
+    let previousInput = {}, previousSnapshot = {};
+    return {
+        begin(input, assertActive, record) {
+            const inputValues = input;
+            const snapshot = captureParameters(inputValues, previousInput, previousSnapshot);
+            const keySignature = JSON.stringify(Object.keys(snapshot));
+            // This proxy is never redirected to a later snapshot: aliases within memo calls remain
+            // ordinary JavaScript identities and every late read still checks its original revision.
+            const params = new Proxy(snapshot, {
+                get(target, key) {
+                    assertActive();
+                    const value = Reflect.get(target, key);
+                    if (typeof key === "string")
+                        record(key, value);
+                    return value;
+                },
+                set: immutable,
+                deleteProperty: immutable,
+                ownKeys(target) {
+                    assertActive();
+                    record(keys, keySignature);
+                    return Reflect.ownKeys(target);
+                },
+                has(target, key) {
+                    assertActive();
+                    record(keys, keySignature);
+                    return Reflect.has(target, key);
+                },
+                getOwnPropertyDescriptor(target, key) {
+                    assertActive();
+                    record(keys, keySignature);
+                    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+                    if (typeof key === "string")
+                        record(key, descriptor?.value);
+                    return descriptor;
+                },
+            });
+            return {
+                params,
+                retainedValues: [snapshot, inputValues],
+                has: (key) => Object.hasOwn(snapshot, key),
+                // Cache validation reads the snapshot directly; using the proxy would record those
+                // internal comparisons as new model dependencies.
+                read: (key) => key === keys ? keySignature : Reflect.get(snapshot, key),
+                commit() {
+                    previousInput = { ...inputValues };
+                    previousSnapshot = snapshot;
+                },
+            };
+        },
+        clear() {
+            previousInput = {};
+            previousSnapshot = {};
+        },
+    };
+}

package/dist/engine/session/session.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveModelingLimits } from "../../geometry/model-limits.js";
+import { resolveModelingLimits } from "../../geometry/limits.js";
 import { bindModelContext } from "../../model/execution-binding.js";
 import { GenerationError } from "../../model/generation.js";
 import { captureGenerationValue } from "../../model/immutable-generation-data.js";
@@ -29,7 +29,7 @@ export function createSession(program, suppliedOptions, engineLimits, transactio
     // owns their fixed lifetime; copying their enumerable fields would change their semantics.
     const services = (options.services ?? Object.freeze({}));
     const caches = {
-        graph: createGenerationGraph(options, limits.maxParts),
+        graph: createGenerationGraph(options, limits),
         snapshots: createSnapshotCache(options, limits),
         geometry: createNativeGeometryCache(),
         clear() {

package/dist/engine/session/snapshot-cache.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../../geometry/errors.js";
 import { isImmutableBuffer, ownImmutableBuffer } from "../../geometry/immutable-buffer.js";
-import { transform3 } from "../../geometry/transform-value.js";
-import { validateRigidTransform3 } from "../../geometry/transform3.js";
+import { validateRigidTransform3 } from "../../geometry/transforms/affine3.js";
+import { transform3 } from "../../geometry/transforms/value.js";
 import { createGeometryFinalizer } from "../finalization.js";
 import { requireModelPart } from "../model-parts.js";
 import { createModelSummary } from "../model-summary.js";