ducjs 3.2.0 → 3.2.1

package/dist/ducjs_wasm.d.ts

@@ -1,23 +1,21 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Fetch a single external file from a `.duc` buffer by file ID.
- *
- * Returns the file entry as a JS object, or `undefined` if not found.
- */
-export function getExternalFile(buf: Uint8Array, file_id: string): any;
-/**
- * Restore a specific checkpoint by its ID from a `.duc` file buffer.
+ * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
  *
- * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
  */
-export function restoreCheckpoint(duc_buf: Uint8Array, checkpoint_id: string): any;
+export function parseDucLazy(buf: Uint8Array): any;
 /**
  * List all versions (checkpoints + deltas) from a `.duc` file buffer.
  *
  * Returns a JS array of `VersionEntry` objects (no heavy data blobs).
  */
 export function listVersions(duc_buf: Uint8Array): any;
+/**
+ * Parse a `.duc` file (Uint8Array) into a JS object (ExportedDataState).
+ */
+export function parseDuc(buf: Uint8Array): any;
 /**
  * Read the full VersionGraph from a `.duc` file buffer.
  *
@@ -26,23 +24,26 @@ export function listVersions(duc_buf: Uint8Array): any;
  */
 export function readVersionGraph(duc_buf: Uint8Array): any;
 /**
- * Returns the current version-control schema version defined in Rust.
+ * Apply a changeset to reconstruct document state.
  *
- * TypeScript should use this as the source of truth instead of hardcoding
- * its own constant. When this value is bumped in Rust, the version control
- * system will automatically handle migration bookkeeping (closing old chains,
- * recording migrations) the next time a checkpoint or delta is created.
+ * `base_state` must be the exact checkpoint data used when the changeset
+ * was created. Returns the full document state as `Uint8Array`.
+ *
+ * Handles all changeset formats transparently:
+ *   - v3 (bsdiff), v2 (XOR diff), v1 (zlib full snapshot)
  */
-export function getCurrentSchemaVersion(): number;
+export function applyDeltaChangeset(base_state: Uint8Array, changeset: Uint8Array): Uint8Array;
 /**
- * Restore the document state at `version_number` from a `.duc` file buffer.
+ * Compute a checkpoint-relative binary diff changeset using bsdiff.
  *
- * The `.duc` file is a SQLite database — this function opens it and queries
- * the `checkpoints` / `deltas` tables directly for version restoration.
+ * `base_state` is the checkpoint's full data blob.
+ * `current_state` is the full document state at the new version.
  *
- * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * Returns an encoded changeset (`Uint8Array`) ready for storage in a
+ * `Delta.payload`. bsdiff finds matching blocks even when they shift
+ * offsets, which is critical for SQLite databases.
  */
-export function restoreVersion(duc_buf: Uint8Array, version_number: number): any;
+export function createDeltaChangeset(base_state: Uint8Array, current_state: Uint8Array): Uint8Array;
 /**
  * Revert the document to a specific version, removing all newer versions.
  *
@@ -50,15 +51,11 @@ export function restoreVersion(duc_buf: Uint8Array, version_number: number): any
  */
 export function revertToVersion(duc_buf: Uint8Array, target_version: number): any;
 /**
- * Apply a changeset to reconstruct document state.
- *
- * `base_state` must be the exact checkpoint data used when the changeset
- * was created. Returns the full document state as `Uint8Array`.
+ * Restore a specific checkpoint by its ID from a `.duc` file buffer.
  *
- * Handles all changeset formats transparently:
- *   - v3 (bsdiff), v2 (XOR diff), v1 (zlib full snapshot)
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
  */
-export function applyDeltaChangeset(base_state: Uint8Array, changeset: Uint8Array): Uint8Array;
+export function restoreCheckpoint(duc_buf: Uint8Array, checkpoint_id: string): any;
 /**
  * List metadata for all external files (without loading the heavy data blobs).
  */
@@ -68,26 +65,29 @@ export function listExternalFiles(buf: Uint8Array): any;
  */
 export function serializeDuc(data: any): Uint8Array;
 /**
- * Compute a checkpoint-relative binary diff changeset using bsdiff.
- *
- * `base_state` is the checkpoint's full data blob.
- * `current_state` is the full document state at the new version.
+ * Fetch a single external file from a `.duc` buffer by file ID.
  *
- * Returns an encoded changeset (`Uint8Array`) ready for storage in a
- * `Delta.payload`. bsdiff finds matching blocks even when they shift
- * offsets, which is critical for SQLite databases.
+ * Returns the file entry as a JS object, or `undefined` if not found.
  */
-export function createDeltaChangeset(base_state: Uint8Array, current_state: Uint8Array): Uint8Array;
+export function getExternalFile(buf: Uint8Array, file_id: string): any;
 /**
- * Parse a `.duc` file (Uint8Array) into a JS object (ExportedDataState).
+ * Returns the current version-control schema version defined in Rust.
+ *
+ * TypeScript should use this as the source of truth instead of hardcoding
+ * its own constant. When this value is bumped in Rust, the version control
+ * system will automatically handle migration bookkeeping (closing old chains,
+ * recording migrations) the next time a checkpoint or delta is created.
  */
-export function parseDuc(buf: Uint8Array): any;
+export function getCurrentSchemaVersion(): number;
 /**
- * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
+ * Restore the document state at `version_number` from a `.duc` file buffer.
  *
- * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
+ * The `.duc` file is a SQLite database — this function opens it and queries
+ * the `checkpoints` / `deltas` tables directly for version restoration.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
  */
-export function parseDucLazy(buf: Uint8Array): any;
+export function restoreVersion(duc_buf: Uint8Array, version_number: number): any;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 

package/dist/ducjs_wasm.js

@@ -195,19 +195,16 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 /**
- * Fetch a single external file from a `.duc` buffer by file ID.
+ * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
  *
- * Returns the file entry as a JS object, or `undefined` if not found.
+ * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
  * @param {Uint8Array} buf
- * @param {string} file_id
  * @returns {any}
  */
-export function getExternalFile(buf, file_id) {
+export function parseDucLazy(buf) {
     const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(file_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.getExternalFile(ptr0, len0, ptr1, len1);
+    const ret = wasm.parseDucLazy(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -215,19 +212,16 @@ export function getExternalFile(buf, file_id) {
 }
 
 /**
- * Restore a specific checkpoint by its ID from a `.duc` file buffer.
+ * List all versions (checkpoints + deltas) from a `.duc` file buffer.
  *
- * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * Returns a JS array of `VersionEntry` objects (no heavy data blobs).
  * @param {Uint8Array} duc_buf
- * @param {string} checkpoint_id
  * @returns {any}
  */
-export function restoreCheckpoint(duc_buf, checkpoint_id) {
+export function listVersions(duc_buf) {
     const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(checkpoint_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.restoreCheckpoint(ptr0, len0, ptr1, len1);
+    const ret = wasm.listVersions(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -235,16 +229,14 @@ export function restoreCheckpoint(duc_buf, checkpoint_id) {
 }
 
 /**
- * List all versions (checkpoints + deltas) from a `.duc` file buffer.
- *
- * Returns a JS array of `VersionEntry` objects (no heavy data blobs).
- * @param {Uint8Array} duc_buf
+ * Parse a `.duc` file (Uint8Array) into a JS object (ExportedDataState).
+ * @param {Uint8Array} buf
  * @returns {any}
  */
-export function listVersions(duc_buf) {
-    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+export function parseDuc(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.listVersions(ptr0, len0);
+    const ret = wasm.parseDuc(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -270,37 +262,56 @@ export function readVersionGraph(duc_buf) {
 }
 
 /**
- * Returns the current version-control schema version defined in Rust.
+ * Apply a changeset to reconstruct document state.
  *
- * TypeScript should use this as the source of truth instead of hardcoding
- * its own constant. When this value is bumped in Rust, the version control
- * system will automatically handle migration bookkeeping (closing old chains,
- * recording migrations) the next time a checkpoint or delta is created.
- * @returns {number}
+ * `base_state` must be the exact checkpoint data used when the changeset
+ * was created. Returns the full document state as `Uint8Array`.
+ *
+ * Handles all changeset formats transparently:
+ *   - v3 (bsdiff), v2 (XOR diff), v1 (zlib full snapshot)
+ * @param {Uint8Array} base_state
+ * @param {Uint8Array} changeset
+ * @returns {Uint8Array}
  */
-export function getCurrentSchemaVersion() {
-    return 3000002;
+export function applyDeltaChangeset(base_state, changeset) {
+    const ptr0 = passArray8ToWasm0(base_state, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(changeset, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.applyDeltaChangeset(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
 }
 
 /**
- * Restore the document state at `version_number` from a `.duc` file buffer.
+ * Compute a checkpoint-relative binary diff changeset using bsdiff.
  *
- * The `.duc` file is a SQLite database — this function opens it and queries
- * the `checkpoints` / `deltas` tables directly for version restoration.
+ * `base_state` is the checkpoint's full data blob.
+ * `current_state` is the full document state at the new version.
  *
- * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
- * @param {Uint8Array} duc_buf
- * @param {number} version_number
- * @returns {any}
+ * Returns an encoded changeset (`Uint8Array`) ready for storage in a
+ * `Delta.payload`. bsdiff finds matching blocks even when they shift
+ * offsets, which is critical for SQLite databases.
+ * @param {Uint8Array} base_state
+ * @param {Uint8Array} current_state
+ * @returns {Uint8Array}
  */
-export function restoreVersion(duc_buf, version_number) {
-    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+export function createDeltaChangeset(base_state, current_state) {
+    const ptr0 = passArray8ToWasm0(base_state, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.restoreVersion(ptr0, len0, version_number);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+    const ptr1 = passArray8ToWasm0(current_state, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.createDeltaChangeset(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
 }
 
 /**
@@ -322,29 +333,23 @@ export function revertToVersion(duc_buf, target_version) {
 }
 
 /**
- * Apply a changeset to reconstruct document state.
- *
- * `base_state` must be the exact checkpoint data used when the changeset
- * was created. Returns the full document state as `Uint8Array`.
+ * Restore a specific checkpoint by its ID from a `.duc` file buffer.
  *
- * Handles all changeset formats transparently:
- *   - v3 (bsdiff), v2 (XOR diff), v1 (zlib full snapshot)
- * @param {Uint8Array} base_state
- * @param {Uint8Array} changeset
- * @returns {Uint8Array}
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * @param {Uint8Array} duc_buf
+ * @param {string} checkpoint_id
+ * @returns {any}
  */
-export function applyDeltaChangeset(base_state, changeset) {
-    const ptr0 = passArray8ToWasm0(base_state, wasm.__wbindgen_malloc);
+export function restoreCheckpoint(duc_buf, checkpoint_id) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(changeset, wasm.__wbindgen_malloc);
+    const ptr1 = passStringToWasm0(checkpoint_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.applyDeltaChangeset(ptr0, len0, ptr1, len1);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    const ret = wasm.restoreCheckpoint(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -378,41 +383,19 @@ export function serializeDuc(data) {
 }
 
 /**
- * Compute a checkpoint-relative binary diff changeset using bsdiff.
- *
- * `base_state` is the checkpoint's full data blob.
- * `current_state` is the full document state at the new version.
+ * Fetch a single external file from a `.duc` buffer by file ID.
  *
- * Returns an encoded changeset (`Uint8Array`) ready for storage in a
- * `Delta.payload`. bsdiff finds matching blocks even when they shift
- * offsets, which is critical for SQLite databases.
- * @param {Uint8Array} base_state
- * @param {Uint8Array} current_state
- * @returns {Uint8Array}
- */
-export function createDeltaChangeset(base_state, current_state) {
-    const ptr0 = passArray8ToWasm0(base_state, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(current_state, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.createDeltaChangeset(ptr0, len0, ptr1, len1);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
-}
-
-/**
- * Parse a `.duc` file (Uint8Array) into a JS object (ExportedDataState).
+ * Returns the file entry as a JS object, or `undefined` if not found.
  * @param {Uint8Array} buf
+ * @param {string} file_id
  * @returns {any}
  */
-export function parseDuc(buf) {
+export function getExternalFile(buf, file_id) {
     const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.parseDuc(ptr0, len0);
+    const ptr1 = passStringToWasm0(file_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.getExternalFile(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -420,16 +403,33 @@ export function parseDuc(buf) {
 }
 
 /**
- * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
+ * Returns the current version-control schema version defined in Rust.
  *
- * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
- * @param {Uint8Array} buf
+ * TypeScript should use this as the source of truth instead of hardcoding
+ * its own constant. When this value is bumped in Rust, the version control
+ * system will automatically handle migration bookkeeping (closing old chains,
+ * recording migrations) the next time a checkpoint or delta is created.
+ * @returns {number}
+ */
+export function getCurrentSchemaVersion() {
+    return 3000003;
+}
+
+/**
+ * Restore the document state at `version_number` from a `.duc` file buffer.
+ *
+ * The `.duc` file is a SQLite database — this function opens it and queries
+ * the `checkpoints` / `deltas` tables directly for version restoration.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * @param {Uint8Array} duc_buf
+ * @param {number} version_number
  * @returns {any}
  */
-export function parseDucLazy(buf) {
-    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+export function restoreVersion(duc_buf, version_number) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.parseDucLazy(ptr0, len0);
+    const ret = wasm.restoreVersion(ptr0, len0, version_number);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }

package/dist/restore/restoreElements.js

@@ -240,7 +240,11 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
                     ? repairBinding(element, endBinding, currentScope, restoredBlocks)
                     : null;
             // Create the base restored element
+            // Skip sizeFromPoints override for block instance elements: their stored
+            // width/height represents the total duplication grid, not single-cell dims.
+            const isBlockInstanceElement = !!element.instanceId;
             const sizeFromPoints = !hasBindings &&
+                !isBlockInstanceElement &&
                 getSizeFromPoints(finalPoints.map(getScopedBezierPointFromDucPoint));
             let restoredElement = restoreElementWithProperties(element, Object.assign({ points: finalPoints, lines, lastCommittedPoint: element.lastCommittedPoint
                     ? restorePoint(element.lastCommittedPoint, element.scope, currentScope)
@@ -329,7 +333,7 @@ const restoreElement = (element, currentScope, restoredBlocks, localState, globa
                 modelType: isValidString(modelElement.modelType) || null,
                 code: isValidString(modelElement.code) || null,
                 fileIds: modelElement.fileIds || [],
-                svgPath: modelElement.svgPath || null,
+                thumbnail: modelElement.thumbnail instanceof Uint8Array ? modelElement.thumbnail : null,
                 viewerState: (modelElement.viewerState || null),
             }, localState, globalState);
         }

package/dist/transform.js

@@ -284,14 +284,95 @@ function fixElementFromRust(el) {
         return el;
     return Object.assign(Object.assign({}, rest), { isCollapsed: (_c = stackBase.isCollapsed) !== null && _c !== void 0 ? _c : false });
 }
+function normalizeViewer3DStateForRust(vs) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!vs || typeof vs !== "object")
+        return vs;
+    const n = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+    const b = (v, fallback) => typeof v === "boolean" ? v : fallback;
+    const s = (v, fallback) => typeof v === "string" ? v : fallback;
+    const arr3 = (v, fallback) => Array.isArray(v) && v.length === 3 && v.every((x) => typeof x === "number")
+        ? v
+        : fallback;
+    const arr4 = (v, fallback) => Array.isArray(v) && v.length === 4 && v.every((x) => typeof x === "number")
+        ? v
+        : fallback;
+    const cam = (_a = vs.camera) !== null && _a !== void 0 ? _a : {};
+    const dsp = (_b = vs.display) !== null && _b !== void 0 ? _b : {};
+    const mat = (_c = vs.material) !== null && _c !== void 0 ? _c : {};
+    const clip = (_d = vs.clipping) !== null && _d !== void 0 ? _d : {};
+    const expl = (_e = vs.explode) !== null && _e !== void 0 ? _e : {};
+    const zeb = (_f = vs.zebra) !== null && _f !== void 0 ? _f : {};
+    const normalizeClipPlane = (cp) => ({
+        enabled: b(cp === null || cp === void 0 ? void 0 : cp.enabled, false),
+        value: n(cp === null || cp === void 0 ? void 0 : cp.value, 0),
+        normal: (cp === null || cp === void 0 ? void 0 : cp.normal) != null ? arr3(cp.normal, [0, 0, 0]) : null,
+    });
+    return {
+        camera: {
+            control: s(cam.control, "orbit"),
+            ortho: b(cam.ortho, true),
+            up: s(cam.up, "Z"),
+            position: arr3(cam.position, [0, 0, 0]),
+            quaternion: arr4(cam.quaternion, [0, 0, 0, 1]),
+            target: arr3(cam.target, [0, 0, 0]),
+            zoom: n(cam.zoom, 1),
+            panSpeed: n(cam.panSpeed, 1),
+            rotateSpeed: n(cam.rotateSpeed, 1),
+            zoomSpeed: n(cam.zoomSpeed, 1),
+            holroyd: b(cam.holroyd, false),
+        },
+        display: {
+            wireframe: b(dsp.wireframe, false),
+            transparent: b(dsp.transparent, false),
+            blackEdges: b(dsp.blackEdges, true),
+            grid: (_g = dsp.grid) !== null && _g !== void 0 ? _g : { type: "uniform", value: false },
+            axesVisible: b(dsp.axesVisible, false),
+            axesAtOrigin: b(dsp.axesAtOrigin, true),
+        },
+        material: {
+            metalness: n(mat.metalness, 0.3),
+            roughness: n(mat.roughness, 0.65),
+            defaultOpacity: n(mat.defaultOpacity, 0.5),
+            edgeColor: n(mat.edgeColor, 0x707070),
+            ambientIntensity: n(mat.ambientIntensity, 1.0),
+            directIntensity: n(mat.directIntensity, 1.1),
+        },
+        clipping: {
+            x: normalizeClipPlane(clip.x),
+            y: normalizeClipPlane(clip.y),
+            z: normalizeClipPlane(clip.z),
+            intersection: b(clip.intersection, false),
+            showPlanes: b(clip.showPlanes, false),
+            objectColorCaps: b(clip.objectColorCaps, false),
+        },
+        explode: {
+            active: b(expl.active, false),
+            value: n(expl.value, 0),
+        },
+        zebra: {
+            active: b(zeb.active, false),
+            stripeCount: toInteger(zeb.stripeCount, 6),
+            stripeDirection: n(zeb.stripeDirection, 0),
+            colorScheme: s(zeb.colorScheme, "blackwhite"),
+            opacity: n(zeb.opacity, 1),
+            mappingMode: s(zeb.mappingMode, "reflection"),
+        },
+    };
+}
 function fixElementToRust(el) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     if (!el)
         return el;
     fixStylesHatch(el, false);
     fixCustomDataToRust(el);
-    if (el.type === "model" && ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid)) {
-        el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridToRust(el.viewerState.display.grid) }) });
+    if (el.type === "model") {
+        if (el.viewerState) {
+            el.viewerState = normalizeViewer3DStateForRust(el.viewerState);
+        }
+        if ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid) {
+            el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridToRust(el.viewerState.display.grid) }) });
+        }
     }
     // Convert TypeScript DucLine tuples [start, end] → Rust structs { start, end }
     if (LINEAR_ELEMENT_TYPES.has(el.type) && Array.isArray(el.lines)) {
@@ -349,6 +430,9 @@ function flattenPrecisionValues(obj) {
         return obj.value;
     if (Array.isArray(obj))
         return obj.map(flattenPrecisionValues);
+    if (ArrayBuffer.isView(obj) || obj instanceof ArrayBuffer) {
+        return obj;
+    }
     if (typeof obj === "object") {
         const out = {};
         for (const key in obj) {

package/dist/types/elements/index.d.ts

@@ -846,8 +846,8 @@ export type DucModelElement = _DucElementBase & {
     modelType: string | null;
     /** Defines the source code of the model using build123d python code */
     code: string | null;
-    /** The last known SVG path representation of the 3D model for quick rendering on the canvas */
-    svgPath: string | null;
+    /** The last known image thumbnail of the 3D model for quick rendering on the canvas */
+    thumbnail: Uint8Array | null;
     /** Possibly connected external files, such as STEP, STL, DXF, etc. */
     fileIds: ExternalFileId[];
     /** The last known 3D viewer state for the model */

package/dist/types/index.d.ts

@@ -101,7 +101,7 @@ export type SuggestedPointBinding = [
     "start" | "end" | "both",
     NonDeleted<DucBindableElement>
 ];
-export type ToolType = "selection" | "rectangle" | "polygon" | "ellipse" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "plot" | "embeddable" | "ruler" | "lasso" | "laser" | "table" | "doc" | "pdf";
+export type ToolType = "selection" | "rectangle" | "polygon" | "ellipse" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "plot" | "embeddable" | "ruler" | "lasso" | "laser" | "table" | "doc" | "pdf" | "model";
 export type ElementOrToolType = DucElementType | ToolType | "custom";
 /**
  * Defines the global, persistent settings for the drawing. These are fundamental

package/dist/utils/elements/newElement.js

@@ -159,7 +159,7 @@ export const newDocElement = (currentScope, opts) => {
         } }));
 };
 export const newPdfElement = (currentScope, opts) => (Object.assign(Object.assign({ fileId: null, gridConfig: { columns: 1, gapX: 0, gapY: 0, firstPageAlone: false, scale: 1 } }, _newElementBase("pdf", currentScope, opts)), { type: "pdf" }));
-export const newModelElement = (currentScope, opts) => (Object.assign(Object.assign({ modelType: null, code: null, svgPath: null, fileIds: [], viewerState: null }, _newElementBase("model", currentScope, opts)), { type: 'model' }));
+export const newModelElement = (currentScope, opts) => (Object.assign(Object.assign({ modelType: null, code: null, thumbnail: null, fileIds: [], viewerState: null }, _newElementBase("model", currentScope, opts)), { type: 'model' }));
 // Simplified deep clone for the purpose of cloning DucElement.
 //
 // Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
@@ -174,6 +174,9 @@ const _deepCopyElement = (val, depth = 0) => {
     if (val == null || typeof val !== "object") {
         return val;
     }
+    if (ArrayBuffer.isView(val)) {
+        return val.slice(0);
+    }
     const objectType = Object.prototype.toString.call(val);
     if (objectType === "[object Object]") {
         const tmp = typeof val.constructor === "function"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ducjs",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "The duc 2D CAD file format is a cornerstone of our advanced design system, conceived to cater to professionals seeking precision and efficiency in their design work.",
   "type": "module",
   "main": "dist/index.js",