ducjs 3.1.1 → 3.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <br/>
-  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://raw.githubusercontent.com/ducflair/assets/refs/heads/main/src/duc/duc-extended.png" /></a>
+  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://cdn.jsdelivr.net/gh/ducflair/assets@main/src/duc/duc-extended.png" /></a>
   <p align="center">2D CAD File Format</p>
   <p align="center" style="align: center;">
     <a href="https://www.npmjs.com/package/ducjs"><img src="https://shields.io/badge/NPM-cc3534?logo=Npm&logoColor=white&style=round-square" alt="NPM" /></a>

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 3000001;
+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/enums.d.ts

@@ -95,11 +95,6 @@ export declare enum IMAGE_STATUS {
     SAVED = 11,
     ERROR = 12
 }
-export declare enum PRUNING_LEVEL {
-    CONSERVATIVE = 10,
-    BALANCED = 20,
-    AGGRESSIVE = 30
-}
 export declare enum BOOLEAN_OPERATION {
     UNION = 10,
     SUBTRACT = 11,

package/dist/enums.js

@@ -109,12 +109,6 @@ export var IMAGE_STATUS;
     IMAGE_STATUS[IMAGE_STATUS["SAVED"] = 11] = "SAVED";
     IMAGE_STATUS[IMAGE_STATUS["ERROR"] = 12] = "ERROR";
 })(IMAGE_STATUS || (IMAGE_STATUS = {}));
-export var PRUNING_LEVEL;
-(function (PRUNING_LEVEL) {
-    PRUNING_LEVEL[PRUNING_LEVEL["CONSERVATIVE"] = 10] = "CONSERVATIVE";
-    PRUNING_LEVEL[PRUNING_LEVEL["BALANCED"] = 20] = "BALANCED";
-    PRUNING_LEVEL[PRUNING_LEVEL["AGGRESSIVE"] = 30] = "AGGRESSIVE";
-})(PRUNING_LEVEL || (PRUNING_LEVEL = {}));
 export var BOOLEAN_OPERATION;
 (function (BOOLEAN_OPERATION) {
     BOOLEAN_OPERATION[BOOLEAN_OPERATION["UNION"] = 10] = "UNION";

package/dist/lazy-files.d.ts

@@ -1,4 +1,4 @@
-import type { DucExternalFile, DucExternalFiles, ExternalFileRevision } from "./types";
+import type { DucExternalFile, DucExternalFiles, ExternalFileLoaded, ResolvedFileData, ExternalFilesData } from "./types";
 export type LazyFileMetadata = {
     id: string;
     mimeType: string;
@@ -27,19 +27,21 @@ export declare class LazyExternalFileStore {
     /** Get metadata for all files. */
     getAllMetadata(): LazyFileMetadata[];
     /** Fetch the full file (including data blobs for all revisions) for a specific file. */
-    getFile(fileId: string): DucExternalFile | null;
+    getFile(fileId: string): ExternalFileLoaded | null;
     /** Get the active revision data for a specific file. */
-    getFileData(fileId: string): ExternalFileRevision | null;
+    getFileData(fileId: string): ResolvedFileData | null;
     /** Fetch active revision data and return a copy of the data buffer (safe for transfer). */
-    getFileDataCopy(fileId: string): ExternalFileRevision | null;
+    getFileDataCopy(fileId: string): ResolvedFileData | null;
     /** Add a file at runtime (not persisted in .duc until next serialize). */
-    addRuntimeFile(fileId: string, file: DucExternalFile): void;
+    addRuntimeFile(fileId: string, file: DucExternalFile, data: Record<string, Uint8Array>): void;
     /** Remove a runtime file. */
     removeRuntimeFile(fileId: string): boolean;
-    /** Export all files eagerly as a DucExternalFiles record. */
+    /** Export all files metadata as a DucExternalFiles record. */
     toExternalFiles(): DucExternalFiles;
+    /** Export all revision data blobs as an ExternalFilesData record. */
+    toExternalFilesData(): ExternalFilesData;
     /** Merge files from another source. Adds missing files and merges new revisions into existing ones. */
-    mergeFiles(files: DucExternalFiles): void;
+    mergeFiles(files: DucExternalFiles, filesData?: ExternalFilesData): void;
     /** Release the underlying buffer to free memory. */
     release(): void;
     private getMetadataMap;

package/dist/lazy-files.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { wasmGetExternalFile, wasmListExternalFiles } from "./wasm";
 /**
  * Provides lazy access to external files embedded inside a `.duc` buffer.
@@ -76,11 +87,16 @@ export class LazyExternalFileStore {
     }
     /** Get the active revision data for a specific file. */
     getFileData(fileId) {
-        var _a;
-        const file = this.getFile(fileId);
-        if (!file)
+        const loaded = this.getFile(fileId);
+        if (!loaded)
+            return null;
+        const meta = loaded.revisions[loaded.activeRevisionId];
+        if (!meta)
             return null;
-        return (_a = file.revisions[file.activeRevisionId]) !== null && _a !== void 0 ? _a : null;
+        const dataBlob = loaded.data[loaded.activeRevisionId];
+        if (!dataBlob)
+            return null;
+        return { data: dataBlob, mimeType: meta.mimeType };
     }
     /** Fetch active revision data and return a copy of the data buffer (safe for transfer). */
     getFileDataCopy(fileId) {
@@ -90,53 +106,97 @@ export class LazyExternalFileStore {
         return Object.assign(Object.assign({}, data), { data: new Uint8Array(data.data) });
     }
     /** Add a file at runtime (not persisted in .duc until next serialize). */
-    addRuntimeFile(fileId, file) {
-        this.runtimeFiles.set(fileId, file);
+    addRuntimeFile(fileId, file, data) {
+        this.runtimeFiles.set(fileId, Object.assign(Object.assign({}, file), { data }));
     }
     /** Remove a runtime file. */
     removeRuntimeFile(fileId) {
         return this.runtimeFiles.delete(fileId);
     }
-    /** Export all files eagerly as a DucExternalFiles record. */
+    /** Export all files metadata as a DucExternalFiles record. */
     toExternalFiles() {
         const result = {};
         if (this.buffer) {
             for (const [id] of this.getMetadataMap()) {
-                const file = this.getFile(id);
-                if (file) {
+                const loaded = this.getFile(id);
+                if (loaded) {
+                    const { data: _ } = loaded, file = __rest(loaded, ["data"]);
                     result[id] = file;
                 }
             }
         }
-        for (const [id, file] of this.runtimeFiles) {
+        for (const [id, loaded] of this.runtimeFiles) {
+            const { data: _ } = loaded, file = __rest(loaded, ["data"]);
             result[id] = file;
         }
         return result;
     }
+    /** Export all revision data blobs as an ExternalFilesData record. */
+    toExternalFilesData() {
+        const result = {};
+        if (this.buffer) {
+            for (const [id] of this.getMetadataMap()) {
+                const loaded = this.getFile(id);
+                if (loaded) {
+                    for (const [revId, blob] of Object.entries(loaded.data)) {
+                        result[revId] = blob;
+                    }
+                }
+            }
+        }
+        for (const [, loaded] of this.runtimeFiles) {
+            for (const [revId, blob] of Object.entries(loaded.data)) {
+                result[revId] = blob;
+            }
+        }
+        return result;
+    }
     /** Merge files from another source. Adds missing files and merges new revisions into existing ones. */
-    mergeFiles(files) {
+    mergeFiles(files, filesData) {
         var _a, _b, _c;
         for (const [id, file] of Object.entries(files)) {
-            if (!this.has(id)) {
-                this.runtimeFiles.set(id, file);
-                continue;
-            }
             const existing = (_a = this.runtimeFiles.get(id)) !== null && _a !== void 0 ? _a : this.getFile(id);
             if (!existing) {
-                this.runtimeFiles.set(id, file);
+                const dataMap = {};
+                if (filesData) {
+                    for (const revId of Object.keys(file.revisions)) {
+                        if (filesData[revId]) {
+                            dataMap[revId] = filesData[revId];
+                        }
+                    }
+                }
+                this.runtimeFiles.set(id, Object.assign(Object.assign({}, file), { data: dataMap }));
                 continue;
             }
-            // Merge: add any new revisions that don't exist yet, and update metadata
             let merged = false;
             const mergedRevisions = Object.assign({}, existing.revisions);
+            const mergedData = Object.assign({}, existing.data);
             for (const [revId, rev] of Object.entries(file.revisions)) {
                 if (!mergedRevisions[revId]) {
+                    mergedRevisions[revId] = rev;
+                    if (filesData === null || filesData === void 0 ? void 0 : filesData[revId]) {
+                        mergedData[revId] = filesData[revId];
+                    }
+                    merged = true;
+                    continue;
+                }
+                if ((filesData === null || filesData === void 0 ? void 0 : filesData[revId]) && mergedData[revId] !== filesData[revId]) {
+                    mergedData[revId] = filesData[revId];
+                    merged = true;
+                }
+                if (rev.sizeBytes !== mergedRevisions[revId].sizeBytes ||
+                    rev.lastRetrieved !== mergedRevisions[revId].lastRetrieved ||
+                    rev.created !== mergedRevisions[revId].created ||
+                    rev.mimeType !== mergedRevisions[revId].mimeType ||
+                    rev.sourceName !== mergedRevisions[revId].sourceName ||
+                    rev.message !== mergedRevisions[revId].message) {
                     mergedRevisions[revId] = rev;
                     merged = true;
                 }
             }
-            if (merged || file.updated > existing.updated) {
-                this.runtimeFiles.set(id, Object.assign(Object.assign({}, existing), { activeRevisionId: file.activeRevisionId, updated: Math.max(file.updated, existing.updated), version: Math.max((_b = file.version) !== null && _b !== void 0 ? _b : 0, (_c = existing.version) !== null && _c !== void 0 ? _c : 0), revisions: mergedRevisions }));
+            const activeRevisionChanged = file.activeRevisionId !== existing.activeRevisionId;
+            if (merged || activeRevisionChanged || file.updated > existing.updated) {
+                this.runtimeFiles.set(id, Object.assign(Object.assign({}, existing), { activeRevisionId: file.activeRevisionId, updated: Math.max(file.updated, existing.updated), version: Math.max((_b = file.version) !== null && _b !== void 0 ? _b : 0, (_c = existing.version) !== null && _c !== void 0 ? _c : 0), revisions: mergedRevisions, data: mergedData }));
             }
         }
     }

package/dist/parse.js

@@ -80,7 +80,9 @@ export function parseDucLazy(buffer, elementsConfig, restoreConfig) {
         const originalVG = data.versionGraph;
         const lazyFileStore = new LazyExternalFileStore(buffer);
         const files = {};
-        const restored = restore(Object.assign(Object.assign({}, data), { files, 
+        const filesData = {};
+        const restored = restore(Object.assign(Object.assign({}, data), { files,
+            filesData, 
             // Preserve versionGraph from Rust separately; do not run it through restore()
             versionGraph: undefined }), elementsConfig !== null && elementsConfig !== void 0 ? elementsConfig : { syncInvalidIndices: (els) => els }, restoreConfig);
         restored.lazyFileStore = lazyFileStore;

package/dist/restore/restoreDataState.d.ts

@@ -1,5 +1,5 @@
 import { BLENDING } from "../enums";
-import type { Checkpoint, Delta, Dictionary, DucExternalFiles, DucGlobalState, ImportedDataState, LibraryItems, PrecisionValue, Scope, VersionGraph } from "../types";
+import type { Checkpoint, Delta, Dictionary, DucExternalFiles, DucGlobalState, ExternalFilesData, ImportedDataState, LibraryItems, PrecisionValue, Scope, VersionGraph } from "../types";
 import { DucLocalState } from "../types";
 import type { _DucStackBase, BezierMirroring, DucBlock, DucBlockCollection, DucBlockInstance, DucElement, DucGroup, DucHead, DucLayer, DucRegion, ElementBackground, ElementContentBase, ElementStroke, ExternalFileId, FillStyle, ImageStatus, LineHead, OrderedDucElement, StrokeCap, StrokeJoin, StrokePreference, StrokeSidePreference, StrokeStyle, TextAlign, VerticalAlign } from "../types/elements";
 import { Percentage, Radian } from "../types/geometryTypes";
@@ -13,6 +13,7 @@ export type RestoredDataState = {
     localState: RestoredLocalState;
     globalState: DucGlobalState;
     files: DucExternalFiles;
+    filesData: ExternalFilesData;
     blocks: DucBlock[];
     blockInstances: DucBlockInstance[];
     blockCollections: DucBlockCollection[];
@@ -47,6 +48,11 @@ export type RestoreConfig = {
 };
 export declare const restore: (data: ImportedDataState | null, elementsConfig: ElementsConfig, restoreConfig?: RestoreConfig) => RestoredDataState;
 export declare const restoreFiles: (importedFiles: unknown) => DucExternalFiles;
+/**
+ * Restore external file data blobs from the split `filesData` field.
+ * Also extracts data from legacy inline `revisions[].data` when present.
+ */
+export declare const restoreFilesData: (importedFilesData: unknown, importedFiles: unknown) => ExternalFilesData;
 export declare const restoreDictionary: (importedDictionary: unknown) => Dictionary;
 /**
  * Restores the groups array from imported data, ensuring each item

package/dist/restore/restoreDataState.js

@@ -1,6 +1,6 @@
 import { nanoid } from "nanoid";
 import tinycolor from "tinycolor2";
-import { BEZIER_MIRRORING, BLENDING, BOOLEAN_OPERATION, ELEMENT_CONTENT_PREFERENCE, IMAGE_STATUS, LINE_HEAD, PRUNING_LEVEL, STROKE_CAP, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, STROKE_SIDE_PREFERENCE, TEXT_ALIGN, VERTICAL_ALIGN, } from "../enums";
+import { BEZIER_MIRRORING, BLENDING, BOOLEAN_OPERATION, ELEMENT_CONTENT_PREFERENCE, IMAGE_STATUS, LINE_HEAD, STROKE_CAP, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, STROKE_SIDE_PREFERENCE, TEXT_ALIGN, VERTICAL_ALIGN, } from "../enums";
 import { getPrecisionScope } from "../technical/measurements";
 import { getPrecisionValueFromRaw, getPrecisionValueFromScoped, NEUTRAL_SCOPE, ScaleFactors } from "../technical/scopes";
 import { base64ToUint8Array, getDefaultGlobalState, getDefaultLocalState, getZoom, isEncodedFunctionString, isFiniteNumber, reviveEncodedFunction, } from "../utils";
@@ -37,11 +37,11 @@ export const restore = (data, elementsConfig, restoreConfig = {}) => {
         localState: restoredLocalState,
         globalState: restoredGlobalState,
         files: restoreFiles(data === null || data === void 0 ? void 0 : data.files),
+        filesData: restoreFilesData(data === null || data === void 0 ? void 0 : data.filesData, data === null || data === void 0 ? void 0 : data.files),
         id: restoredId,
     };
 };
 export const restoreFiles = (importedFiles) => {
-    var _a, _b;
     if (!importedFiles || typeof importedFiles !== "object") {
         return {};
     }
@@ -70,20 +70,17 @@ export const restoreFiles = (importedFiles) => {
                 const r = rev;
                 const revId = isValidString(r.id);
                 const mimeType = isValidString(r.mimeType);
-                const dataSource = (_a = r.data) !== null && _a !== void 0 ? _a : r.dataURL;
-                const data = isValidUint8Array(dataSource);
-                if (!revId || !mimeType || !data)
+                if (!revId || !mimeType)
                     continue;
                 restoredRevisions[revKey] = {
                     id: revId,
-                    sizeBytes: isFiniteNumber(r.sizeBytes) ? r.sizeBytes : data.byteLength,
+                    sizeBytes: isFiniteNumber(r.sizeBytes) ? r.sizeBytes : 0,
                     checksum: isValidString(r.checksum) || undefined,
                     sourceName: isValidString(r.sourceName) || undefined,
                     mimeType,
                     message: isValidString(r.message) || undefined,
                     created: isFiniteNumber(r.created) ? r.created : Date.now(),
                     lastRetrieved: isFiniteNumber(r.lastRetrieved) ? r.lastRetrieved : undefined,
-                    data,
                 };
             }
             if (Object.keys(restoredRevisions).length === 0)
@@ -99,15 +96,12 @@ export const restoreFiles = (importedFiles) => {
         }
         // Legacy flat format: DucExternalFileData — wrap in a single-revision DucExternalFile.
         let legacyData = fd;
-        // Handle the nested { key, value: { ... } } structure from old Rust serde output.
         if (fd.value && typeof fd.value === "object") {
             legacyData = fd.value;
         }
         const id = isValidExternalFileId(legacyData.id);
         const mimeType = isValidString(legacyData.mimeType);
-        const dataSource = (_b = legacyData.data) !== null && _b !== void 0 ? _b : legacyData.dataURL;
-        const data = isValidUint8Array(dataSource);
-        if (!id || !mimeType || !data)
+        if (!id || !mimeType)
             continue;
         const revId = `${id}_rev1`;
         const created = isFiniteNumber(legacyData.created) ? legacyData.created : Date.now();
@@ -119,19 +113,87 @@ export const restoreFiles = (importedFiles) => {
             revisions: {
                 [revId]: {
                     id: revId,
-                    sizeBytes: data.byteLength,
+                    sizeBytes: 0,
                     mimeType,
                     created,
                     lastRetrieved: isFiniteNumber(legacyData.lastRetrieved)
                         ? legacyData.lastRetrieved
                         : undefined,
-                    data,
                 },
             },
         };
     }
     return restoredFiles;
 };
+/**
+ * Restore external file data blobs from the split `filesData` field.
+ * Also extracts data from legacy inline `revisions[].data` when present.
+ */
+export const restoreFilesData = (importedFilesData, importedFiles) => {
+    var _a, _b;
+    const result = {};
+    // 1. Restore from the explicit filesData field (new format)
+    if (importedFilesData && typeof importedFilesData === "object") {
+        const fd = importedFilesData;
+        for (const revId in fd) {
+            if (!Object.prototype.hasOwnProperty.call(fd, revId))
+                continue;
+            const data = isValidUint8Array(fd[revId]);
+            if (data) {
+                result[revId] = data;
+            }
+        }
+    }
+    // 2. Extract data from legacy inline revisions (backward compatibility)
+    if (importedFiles && typeof importedFiles === "object") {
+        const files = importedFiles;
+        for (const key in files) {
+            if (!Object.prototype.hasOwnProperty.call(files, key))
+                continue;
+            const fileData = files[key];
+            if (!fileData || typeof fileData !== "object")
+                continue;
+            const fd = fileData;
+            if (fd.revisions && typeof fd.revisions === "object") {
+                const rawRevisions = fd.revisions;
+                for (const revKey in rawRevisions) {
+                    if (!Object.prototype.hasOwnProperty.call(rawRevisions, revKey))
+                        continue;
+                    if (result[revKey])
+                        continue; // filesData takes precedence
+                    const rev = rawRevisions[revKey];
+                    if (!rev || typeof rev !== "object")
+                        continue;
+                    const r = rev;
+                    const dataSource = (_a = r.data) !== null && _a !== void 0 ? _a : r.dataURL;
+                    const data = isValidUint8Array(dataSource);
+                    if (data) {
+                        result[revKey] = data;
+                    }
+                }
+            }
+            else {
+                // Legacy flat format
+                let legacyData = fd;
+                if (fd.value && typeof fd.value === "object") {
+                    legacyData = fd.value;
+                }
+                const id = isValidExternalFileId(legacyData.id);
+                if (!id)
+                    continue;
+                const revId = `${id}_rev1`;
+                if (result[revId])
+                    continue;
+                const dataSource = (_b = legacyData.data) !== null && _b !== void 0 ? _b : legacyData.dataURL;
+                const data = isValidUint8Array(dataSource);
+                if (data) {
+                    result[revId] = data;
+                }
+            }
+        }
+    }
+    return result;
+};
 export const restoreDictionary = (importedDictionary) => {
     if (!importedDictionary || typeof importedDictionary !== "object") {
         return {};
@@ -377,10 +439,7 @@ const restoreBlockMetadata = (metadata) => {
 export const restoreGlobalState = (importedState = {}) => {
     var _a, _b, _c;
     const defaults = getDefaultGlobalState();
-    return Object.assign(Object.assign({}, defaults), { name: (_a = importedState === null || importedState === void 0 ? void 0 : importedState.name) !== null && _a !== void 0 ? _a : defaults.name, viewBackgroundColor: (_b = importedState === null || importedState === void 0 ? void 0 : importedState.viewBackgroundColor) !== null && _b !== void 0 ? _b : defaults.viewBackgroundColor, mainScope: (_c = isValidAppStateScopeValue(importedState === null || importedState === void 0 ? void 0 : importedState.mainScope)) !== null && _c !== void 0 ? _c : defaults.mainScope, scopeExponentThreshold: isValidAppStateScopeExponentThresholdValue(importedState === null || importedState === void 0 ? void 0 : importedState.scopeExponentThreshold, defaults.scopeExponentThreshold), pruningLevel: (importedState === null || importedState === void 0 ? void 0 : importedState.pruningLevel) &&
-            Object.values(PRUNING_LEVEL).includes(importedState.pruningLevel)
-            ? importedState.pruningLevel
-            : PRUNING_LEVEL.BALANCED });
+    return Object.assign(Object.assign({}, defaults), { name: (_a = importedState === null || importedState === void 0 ? void 0 : importedState.name) !== null && _a !== void 0 ? _a : defaults.name, viewBackgroundColor: (_b = importedState === null || importedState === void 0 ? void 0 : importedState.viewBackgroundColor) !== null && _b !== void 0 ? _b : defaults.viewBackgroundColor, mainScope: (_c = isValidAppStateScopeValue(importedState === null || importedState === void 0 ? void 0 : importedState.mainScope)) !== null && _c !== void 0 ? _c : defaults.mainScope, scopeExponentThreshold: isValidAppStateScopeExponentThresholdValue(importedState === null || importedState === void 0 ? void 0 : importedState.scopeExponentThreshold, defaults.scopeExponentThreshold) });
 };
 /**
  * Restores the user's local session state from imported data.
@@ -447,9 +506,6 @@ export const restoreVersionGraph = (importedGraph) => {
         chainCount: isFiniteNumber(importedMetadata === null || importedMetadata === void 0 ? void 0 : importedMetadata.chainCount) && importedMetadata.chainCount >= 1
             ? importedMetadata.chainCount
             : 1,
-        lastPruned: isFiniteNumber(importedMetadata === null || importedMetadata === void 0 ? void 0 : importedMetadata.lastPruned)
-            ? importedMetadata.lastPruned
-            : 0,
         totalSize: isFiniteNumber(importedMetadata === null || importedMetadata === void 0 ? void 0 : importedMetadata.totalSize) &&
             importedMetadata.totalSize >= 0
             ? importedMetadata.totalSize

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) {
@@ -395,7 +479,7 @@ function normalizeLocalStateForRust(localState) {
 function normalizeGlobalStateForRust(globalState) {
     if (!globalState || typeof globalState !== "object")
         return globalState;
-    return Object.assign(Object.assign({}, globalState), { scopeExponentThreshold: toInteger(globalState.scopeExponentThreshold, 4), pruningLevel: toInteger(globalState.pruningLevel, 20) });
+    return Object.assign(Object.assign({}, globalState), { scopeExponentThreshold: toInteger(globalState.scopeExponentThreshold, 4) });
 }
 function easingFnToName(fn) {
     var _a;

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

@@ -2,11 +2,10 @@ export * from "./elements";
 export * from "./geometryTypes";
 export * from "./typeChecks";
 export * from "./utility-types";
-import { PRUNING_LEVEL } from "../enums";
 import { SupportedMeasures } from "../technical/scopes";
-import { DucBindableElement, DucBlock, DucBlockCollection, DucBlockInstance, DucElement, DucElementType, DucGroup, DucIframeLikeElement, DucLayer, DucLinearElement, DucPoint, DucRegion, DucTextElement, ElementBackground, ElementStroke, ExternalFileId, FontFamilyValues, LineHead, NonDeleted, TextAlign } from "./elements";
-import { GeometricPoint, Percentage, Radian } from "./geometryTypes";
-import { MarkOptional, MaybePromise, ValueOf } from "./utility-types";
+import { DucBindableElement, DucBlock, DucBlockCollection, DucBlockInstance, DucElement, DucElementType, DucGroup, DucIframeLikeElement, DucLayer, DucLinearElement, DucRegion, DucTextElement, ElementBackground, ElementStroke, ExternalFileId, FontFamilyValues, LineHead, NonDeleted, TextAlign } from "./elements";
+import { Percentage } from "./geometryTypes";
+import { MarkOptional, MaybePromise } from "./utility-types";
 /**
  * Root data structure for the stored data state
  */
@@ -28,6 +27,8 @@ export interface ExportedDataState {
     regions: readonly DucRegion[];
     layers: readonly DucLayer[];
     files: DucExternalFiles | undefined;
+    /** Revision data blobs keyed by revision id. Separated from metadata for lazy loading. */
+    filesData: ExternalFilesData | undefined;
     /** In case it is needed to embed the version control into the file format */
     versionGraph: VersionGraph | undefined;
     /** Actual file id */
@@ -51,35 +52,8 @@ export type Identifier = {
 export type Dictionary = {
     [key: string]: string;
 };
-export type DucView = {
-    scrollX: PrecisionValue;
-    scrollY: PrecisionValue;
-    zoom: Zoom;
-    twistAngle: Radian;
-    /** The specific spot on that plane that you want to be in the middle of your screen when this view is active */
-    centerPoint: DucPoint;
-    scope: Scope;
-};
-/**
- * Defines a 2D User Coordinate System (UCS), a movable coordinate system
- * that establishes a local origin and rotation for drawing. All coordinates
- * within this UCS are relative to its origin and angle.
- */
-export type DucUcs = {
-    /**
-     * The origin point of the UCS in World Coordinate System (WCS) coordinates.
-     * This defines the (0,0) point of the new local system.
-     */
-    origin: GeometricPoint;
-    /**
-     * The rotation angle of the UCS's X-axis, measured in radians,
-     * relative to the World Coordinate System's X-axis.
-     * An angle of 0 means the UCS is aligned with the WCS.
-     */
-    angle: Radian;
-};
 export type Scope = SupportedMeasures;
-export type ExternalFileRevision = {
+export type ExternalFileRevisionMeta = {
     id: string;
     sizeBytes: number;
     /** Content hash for integrity checks and optional deduplication. */
@@ -96,26 +70,38 @@ export type ExternalFileRevision = {
      * the scene. Used to determine whether to delete unused files from storage.
      */
     lastRetrieved?: number;
-    /** The actual file content bytes. */
+};
+/**
+ * Minimal resolved file data for rendering — just the bytes and their MIME type.
+ * Used by renderers and export pipelines that need active revision data.
+ */
+export type ResolvedFileData = {
     data: Uint8Array;
+    mimeType: string;
 };
 export type DucExternalFile = {
     id: ExternalFileId;
     activeRevisionId: string;
     /** Epoch ms when the logical file was last mutated (revision added or active changed). */
     updated: number;
-    /** All revisions of this file, keyed by their id. */
-    revisions: Record<string, ExternalFileRevision>;
+    /** All revisions of this file, keyed by their id (metadata only, no data blobs). */
+    revisions: Record<string, ExternalFileRevisionMeta>;
     version?: number;
 };
 export type DucExternalFiles = Record<ExternalFileId, DucExternalFile>;
+/** Revision data blobs keyed by revision id. */
+export type ExternalFilesData = Record<string, Uint8Array>;
+/** A fully-loaded external file including its revision data blobs. */
+export type ExternalFileLoaded = DucExternalFile & {
+    data: Record<string, Uint8Array>;
+};
 export type SuggestedBinding = NonDeleted<DucBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<DucLinearElement>,
     "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
@@ -140,8 +126,6 @@ export type DucGlobalState = {
      * This value defines a +/- tolerance range around the exponent of the current scope.
      */
     scopeExponentThreshold: number;
-    /** The level of pruning to the versions from the version graph. */
-    pruningLevel: PruningLevel;
 };
 export type DucLocalState = {
     /**
@@ -277,7 +261,6 @@ export type EmbedsValidationStatus = Map<DucIframeLikeElement["id"], boolean>;
 export type ElementsPendingErasure = Set<DucElement["id"]>;
 export type PendingDucElements = DucElement[];
 export type VersionId = string;
-export type PruningLevel = ValueOf<typeof PRUNING_LEVEL>;
 export interface VersionBase {
     id: VersionId;
     parentId: VersionId | null;
@@ -323,7 +306,6 @@ export interface VersionGraphMetadata {
     currentVersion: number;
     currentSchemaVersion: number;
     chainCount: number;
-    lastPruned: number;
     totalSize: number;
 }
 export interface VersionGraph {

package/dist/utils/constants.d.ts

@@ -17,7 +17,6 @@ export declare const ELEMENT_TRANSLATE_AMOUNT = 1;
 export declare const TEXT_TO_CENTER_SNAP_THRESHOLD = 30;
 export declare const SHIFT_LOCKING_ANGLE: number;
 export declare const DEFAULT_GRID_SIZE = 1;
-export declare const DEFAULT_GRID_STEP = 20;
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
 export declare const IMAGE_MIME_TYPES: {
     readonly svg: "image/svg+xml";

package/dist/utils/constants.js

@@ -20,7 +20,6 @@ export const ELEMENT_TRANSLATE_AMOUNT = 1;
 export const TEXT_TO_CENTER_SNAP_THRESHOLD = 30;
 export const SHIFT_LOCKING_ANGLE = Math.PI / 12;
 export const DEFAULT_GRID_SIZE = 1;
-export const DEFAULT_GRID_STEP = 20;
 export const SVG_NS = "http://www.w3.org/2000/svg";
 export const IMAGE_MIME_TYPES = {
     svg: "image/svg+xml",

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/dist/utils/normalize.d.ts

@@ -1,8 +1,6 @@
 import type { NormalizedZoomValue, ScopedValue } from "../types";
 import { DucElement, FixedPoint } from "../types/elements";
 export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
-export declare const getNormalizedGridSize: (gridStep: number) => number;
-export declare const getNormalizedGridStep: (gridStep: number) => number;
 export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
 export declare const getNormalizedDimensions: (element: Pick<DucElement, "width" | "height" | "x" | "y">) => {
     width: ScopedValue;

package/dist/utils/normalize.js

@@ -3,12 +3,6 @@ import { clamp } from "./math";
 export const getNormalizedZoom = (zoom) => {
     return clamp(zoom, MIN_ZOOM, MAX_ZOOM);
 };
-export const getNormalizedGridSize = (gridStep) => {
-    return clamp(Math.round(gridStep), 1, 100);
-};
-export const getNormalizedGridStep = (gridStep) => {
-    return clamp(Math.round(gridStep), 1, 100);
-};
 export const normalizeFixedPoint = (fixedPoint) => {
     // Do not allow a precise 0.5 for fixed point ratio
     // to avoid jumping arrow heading due to floating point imprecision

package/dist/utils/state/index.js

@@ -1,5 +1,5 @@
 import { isFiniteNumber } from "..";
-import { PRUNING_LEVEL, TEXT_ALIGN } from "../../enums";
+import { TEXT_ALIGN } from "../../enums";
 import { isValidPrecisionScopeValue } from "../../restore/restoreDataState";
 import { getPrecisionValueFromRaw, getScaledZoomValueForScope, getScopedZoomValue, NEUTRAL_SCOPE, } from "../../technical/scopes";
 import { COLOR_PALETTE, DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, } from "../constants";
@@ -26,7 +26,6 @@ export const getDefaultGlobalState = () => {
         viewBackgroundColor: typeof window !== "undefined" ? (window.matchMedia("(prefers-color-scheme: dark)").matches ? COLOR_PALETTE.night : COLOR_PALETTE.white) : COLOR_PALETTE.white,
         scopeExponentThreshold: 3,
         mainScope: NEUTRAL_SCOPE,
-        pruningLevel: PRUNING_LEVEL.BALANCED,
     };
 };
 export const getDefaultLocalState = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ducjs",
-  "version": "3.1.1",
+  "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",