@metamesh/modeling 0.10.0 → 0.11.0

package/dist/model/immutable-buffer.js

@@ -0,0 +1,111 @@
+const constructors = { Float32Array, Float64Array, Uint32Array, Uint8Array, Int32Array };
+const protocol = Symbol.for("@metamesh/modeling/immutable-buffer/1");
+const storage = new WeakMap();
+const adopted = new WeakMap();
+/**
+ * Copies numeric data once into private storage. This pure helper needs no active generation.
+ * @example
+ * ```ts
+ * import { immutableBuffer } from "@metamesh/modeling";
+ * const heights = immutableBuffer(new Float32Array([2, 4, 6]));
+ * const count = heights.length;
+ * const first = heights.at(0);
+ * const editable = heights.copy();
+ * editable[0] = 8; // heights still contains 2, 4, 6.
+ * ```
+ */
+export function immutableBuffer(source) {
+    const entry = Object.entries(constructors).find(([, constructor]) => source instanceof constructor);
+    if (entry === undefined)
+        throw new TypeError("immutableBuffer requires a supported numeric typed array.");
+    const [kind, constructor] = entry;
+    const owned = new constructor(source);
+    const length = owned.length;
+    const result = Object.freeze({
+        [protocol]: kind,
+        length,
+        at: (index) => {
+            const offset = index < 0 ? length + index : index;
+            return Number.isInteger(offset) && offset >= 0 && offset < length ? owned[offset] : undefined;
+        },
+        copy: () => new constructor(owned),
+    });
+    storage.set(result, owned);
+    return result;
+}
+/**
+ * Copies mesh buffers into immutable data; geometric validation still occurs when modeling or finalizing.
+ * @example
+ * ```ts
+ * import { generate, immutableMesh } from "@metamesh/modeling";
+ * import { heightfieldMesh } from "@metamesh/modeling/geometry";
+ * const model = generate(({ computed, part }) => {
+ *   const surface = computed("surface", () => immutableMesh(heightfieldMesh({
+ *     size: [10, 10], segments: [8, 8], height: () => 2,
+ *   })));
+ *   return [part("surface", surface)];
+ * });
+ * ```
+ */
+export function immutableMesh(mesh) {
+    const { positions, indices } = mesh;
+    if (!(positions instanceof Float32Array) || !(indices instanceof Uint32Array))
+        throw new TypeError("immutableMesh requires Float32 positions and Uint32 indices.");
+    return Object.freeze({
+        positions: immutableBuffer(positions),
+        indices: immutableBuffer(indices),
+    });
+}
+/** Recognizes the versioned cross-bundle protocol without invoking foreign callbacks. */
+export function isImmutableBuffer(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (storage.has(value))
+        return true;
+    if (!Object.isFrozen(value))
+        return false;
+    const field = (key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+    };
+    const kind = field(protocol), length = field("length");
+    return (typeof kind === "string" &&
+        Object.hasOwn(constructors, kind) &&
+        typeof length === "number" &&
+        Number.isSafeInteger(length) &&
+        length >= 0 &&
+        typeof field("at") === "function" &&
+        typeof field("copy") === "function");
+}
+/** Adopts separately bundled factories once, copying before trusting their storage or methods. */
+export function adoptImmutableBuffer(buffer) {
+    if (storage.has(buffer))
+        return buffer;
+    const previous = adopted.get(buffer);
+    if (previous !== undefined)
+        return previous;
+    if (!isImmutableBuffer(buffer))
+        throw new TypeError("Expected an immutableBuffer() value.");
+    const source = buffer.copy();
+    const kind = Object.getOwnPropertyDescriptor(buffer, protocol)
+        .value;
+    if (!(source instanceof constructors[kind]))
+        throw new TypeError("An immutable buffer copy must retain its numeric type and length.");
+    const captured = immutableBuffer(source);
+    if (captured.length !== buffer.length)
+        throw new TypeError("An immutable buffer copy must retain its numeric type and length.");
+    adopted.set(buffer, captured);
+    return captured;
+}
+/** Trusted internal read only: never mutate or expose this view or its backing buffer. */
+export function immutableBufferView(buffer) {
+    return storage.get(adoptImmutableBuffer(buffer));
+}
+/** Normalizes trusted modeling/finalization inputs without copying or exposing storage publicly. */
+export function immutableMeshView(mesh) {
+    const { positions, indices } = mesh;
+    return {
+        positions: isImmutableBuffer(positions) ? immutableBufferView(positions) : positions,
+        indices: isImmutableBuffer(indices) ? immutableBufferView(indices) : indices,
+    };
+}

package/dist/model/modeling-context.js

@@ -0,0 +1 @@
+export {};