ducjs 3.0.0 → 3.0.4

package/README.md

@@ -1,3 +1,5 @@
+# ducjs
+
 <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>
@@ -10,9 +12,6 @@
   </p>
 </p>
 
-
-# ducjs
-
 The `ducjs` package offers comprehensive TypeScript types and helper functions to work effortlessly with the `duc` CAD file format. Built with SQLite and optimized for performance, this package enables you to parse, validate, and manipulate `duc` files with ease.
 
 ## Documentation

package/dist/ducjs_wasm.d.ts

@@ -0,0 +1,125 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * 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.
+ *
+ * Returns a JS object matching the `VersionGraph` TypeScript interface,
+ * or `undefined` if no version graph exists.
+ */
+export function readVersionGraph(duc_buf: Uint8Array): any;
+/**
+ * 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;
+/**
+ * Revert the document to a specific version, removing all newer versions.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ */
+export function revertToVersion(duc_buf: Uint8Array, target_version: number): any;
+/**
+ * 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 getCurrentSchemaVersion(): number;
+/**
+ * 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;
+/**
+ * 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 }`.
+ */
+export function restoreVersion(duc_buf: Uint8Array, version_number: number): any;
+/**
+ * Serialize a JS object (ExportedDataState) into `.duc` bytes (Uint8Array).
+ */
+export function serializeDuc(data: any): Uint8Array;
+/**
+ * Restore a specific checkpoint by its ID from a `.duc` file buffer.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ */
+export function restoreCheckpoint(duc_buf: Uint8Array, checkpoint_id: string): any;
+/**
+ * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
+ *
+ * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
+ */
+export function parseDucLazy(buf: Uint8Array): any;
+/**
+ * List metadata for all external files (without loading the heavy data blobs).
+ */
+export function listExternalFiles(buf: Uint8Array): any;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly getCurrentSchemaVersion: () => number;
+  readonly getExternalFile: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly listExternalFiles: (a: number, b: number) => [number, number, number];
+  readonly listVersions: (a: number, b: number) => [number, number, number];
+  readonly parseDuc: (a: number, b: number) => [number, number, number];
+  readonly parseDucLazy: (a: number, b: number) => [number, number, number];
+  readonly readVersionGraph: (a: number, b: number) => [number, number, number];
+  readonly restoreCheckpoint: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly restoreVersion: (a: number, b: number, c: number) => [number, number, number];
+  readonly revertToVersion: (a: number, b: number, c: number) => [number, number, number];
+  readonly serializeDuc: (a: any) => [number, number, number, number];
+  readonly rust_sqlite_wasm_abort: () => void;
+  readonly rust_sqlite_wasm_assert_fail: (a: number, b: number, c: number, d: number) => void;
+  readonly rust_sqlite_wasm_calloc: (a: number, b: number) => number;
+  readonly rust_sqlite_wasm_malloc: (a: number) => number;
+  readonly rust_sqlite_wasm_free: (a: number) => void;
+  readonly rust_sqlite_wasm_getentropy: (a: number, b: number) => number;
+  readonly rust_sqlite_wasm_localtime: (a: number) => number;
+  readonly rust_sqlite_wasm_realloc: (a: number, b: number) => number;
+  readonly sqlite3_os_end: () => number;
+  readonly sqlite3_os_init: () => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_4: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/ducjs_wasm.js

@@ -0,0 +1,797 @@
+let wasm;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_4.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * Parse a `.duc` file (Uint8Array) into a JS object (ExportedDataState).
+ * @param {Uint8Array} buf
+ * @returns {any}
+ */
+export function parseDuc(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseDuc(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Read the full VersionGraph from a `.duc` file buffer.
+ *
+ * Returns a JS object matching the `VersionGraph` TypeScript interface,
+ * or `undefined` if no version graph exists.
+ * @param {Uint8Array} duc_buf
+ * @returns {any}
+ */
+export function readVersionGraph(duc_buf) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.readVersionGraph(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * 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.
+ * @param {Uint8Array} buf
+ * @param {string} file_id
+ * @returns {any}
+ */
+export function getExternalFile(buf, file_id) {
+    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);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Revert the document to a specific version, removing all newer versions.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * @param {Uint8Array} duc_buf
+ * @param {number} target_version
+ * @returns {any}
+ */
+export function revertToVersion(duc_buf, target_version) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.revertToVersion(ptr0, len0, target_version);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * 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.
+ * @returns {number}
+ */
+export function getCurrentSchemaVersion() {
+    return 3000000;
+}
+
+/**
+ * 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
+ * @returns {any}
+ */
+export function listVersions(duc_buf) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.listVersions(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * 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 restoreVersion(duc_buf, version_number) {
+    const ptr0 = passArray8ToWasm0(duc_buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.restoreVersion(ptr0, len0, version_number);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Serialize a JS object (ExportedDataState) into `.duc` bytes (Uint8Array).
+ * @param {any} data
+ * @returns {Uint8Array}
+ */
+export function serializeDuc(data) {
+    const ret = wasm.serializeDuc(data);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+
+/**
+ * Restore a specific checkpoint by its ID from a `.duc` file buffer.
+ *
+ * Returns a JS object `{ versionNumber, schemaVersion, data, fromCheckpoint }`.
+ * @param {Uint8Array} duc_buf
+ * @param {string} checkpoint_id
+ * @returns {any}
+ */
+export function restoreCheckpoint(duc_buf, checkpoint_id) {
+    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);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Parse a `.duc` file lazily — returns everything EXCEPT external file data blobs.
+ *
+ * Use `getExternalFile()` or `listExternalFiles()` for on-demand access.
+ * @param {Uint8Array} buf
+ * @returns {any}
+ */
+export function parseDucLazy(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseDucLazy(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * List metadata for all external files (without loading the heavy data blobs).
+ * @param {Uint8Array} buf
+ * @returns {any}
+ */
+export function listExternalFiles(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.listExternalFiles(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_Number_998bea33bd87c3e0 = function(arg0) {
+        const ret = Number(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_done_75ed0ee6dd243d9d = function(arg0) {
+        const ret = arg0.done;
+        return ret;
+    };
+    imports.wbg.__wbg_entries_2be2f15bd5554996 = function(arg0) {
+        const ret = Object.entries(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_from_88bc52ce20ba6318 = function(arg0) {
+        const ret = Array.from(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_getDate_9615e288fc892247 = function(arg0) {
+        const ret = arg0.getDate();
+        return ret;
+    };
+    imports.wbg.__wbg_getDay_c9c4f57fb4ef6fef = function(arg0) {
+        const ret = arg0.getDay();
+        return ret;
+    };
+    imports.wbg.__wbg_getFullYear_e351a9fa7d2fab83 = function(arg0) {
+        const ret = arg0.getFullYear();
+        return ret;
+    };
+    imports.wbg.__wbg_getHours_4cc14de357c9e723 = function(arg0) {
+        const ret = arg0.getHours();
+        return ret;
+    };
+    imports.wbg.__wbg_getMinutes_6cde8fdd08b0c2ec = function(arg0) {
+        const ret = arg0.getMinutes();
+        return ret;
+    };
+    imports.wbg.__wbg_getMonth_8cc234bce5c8bcac = function(arg0) {
+        const ret = arg0.getMonth();
+        return ret;
+    };
+    imports.wbg.__wbg_getRandomValues_933a06e2370405af = function() { return handleError(function (arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+    }, arguments) };
+    imports.wbg.__wbg_getSeconds_c2f02452d804ece0 = function(arg0) {
+        const ret = arg0.getSeconds();
+        return ret;
+    };
+    imports.wbg.__wbg_getTime_6bb3f64e0f18f817 = function(arg0) {
+        const ret = arg0.getTime();
+        return ret;
+    };
+    imports.wbg.__wbg_getTimezoneOffset_1e3ddc1382e7c8b0 = function(arg0) {
+        const ret = arg0.getTimezoneOffset();
+        return ret;
+    };
+    imports.wbg.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
+        const ret = arg0[arg1];
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof ArrayBuffer;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Map_ebb01a5b6b5ffd0b = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Map;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_9a8378d955933db7 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_030cce220591fb41 = function(arg0) {
+        const ret = Array.isArray(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_isSafeInteger_1c0d1af5542e102a = function(arg0) {
+        const ret = Number.isSafeInteger(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_f370b34483c71a1c = function() {
+        const ret = Symbol.iterator;
+        return ret;
+    };
+    imports.wbg.__wbg_length_186546c51cd61acd = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_new0_b0a0a38c201e6df5 = function() {
+        const ret = new Date();
+        return ret;
+    };
+    imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_2ff1f68f3676ea53 = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_new_5a2ae4557f92b50e = function(arg0) {
+        const ret = new Date(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_638ebfaedbf32a5e = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
+        const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_newwithyearmonthday_9d5466a369f2521d = function(arg0, arg1, arg2) {
+        const ret = new Date(arg0 >>> 0, arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_next_5b3530e612fde77d = function(arg0) {
+        const ret = arg0.next;
+        return ret;
+    };
+    imports.wbg.__wbg_next_692e82279131b03c = function() { return handleError(function (arg0) {
+        const ret = arg0.next();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbg_random_7ed63a0b38ee3b75 = function() {
+        const ret = Math.random();
+        return ret;
+    };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_453345bcda80b89a = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_value_dd9372230531eade = function(arg0) {
+        const ret = arg0.value;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1 = function(arg0, arg1) {
+        const v = arg1;
+        const ret = typeof(v) === 'bigint' ? v : undefined;
+        getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg_wbindgenbooleanget_3fe6f642c7d97746 = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
+    imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_wbindgenin_d7a1ee10933d2d55 = function(arg0, arg1) {
+        const ret = arg0 in arg1;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisbigint_ecb90cc08a5a9154 = function(arg0) {
+        const ret = typeof(arg0) === 'bigint';
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenjsvaleq_e6f2ad59ccae1b58 = function(arg0, arg1) {
+        const ret = arg0 === arg1;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenjsvallooseeq_9bec8c9be826bed1 = function(arg0, arg1) {
+        const ret = arg0 == arg1;
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+        // Cast intrinsic for `I64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+        const ret = getArrayU8FromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+        // Cast intrinsic for `F64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_4;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+        ;
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('ducjs_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;

package/dist/ducjs_wasm_bg.wasm.d.ts

@@ -0,0 +1,32 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const getCurrentSchemaVersion: () => number;
+export const getExternalFile: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const listExternalFiles: (a: number, b: number) => [number, number, number];
+export const listVersions: (a: number, b: number) => [number, number, number];
+export const parseDuc: (a: number, b: number) => [number, number, number];
+export const parseDucLazy: (a: number, b: number) => [number, number, number];
+export const readVersionGraph: (a: number, b: number) => [number, number, number];
+export const restoreCheckpoint: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const restoreVersion: (a: number, b: number, c: number) => [number, number, number];
+export const revertToVersion: (a: number, b: number, c: number) => [number, number, number];
+export const serializeDuc: (a: any) => [number, number, number, number];
+export const rust_sqlite_wasm_abort: () => void;
+export const rust_sqlite_wasm_assert_fail: (a: number, b: number, c: number, d: number) => void;
+export const rust_sqlite_wasm_calloc: (a: number, b: number) => number;
+export const rust_sqlite_wasm_malloc: (a: number) => number;
+export const rust_sqlite_wasm_free: (a: number) => void;
+export const rust_sqlite_wasm_getentropy: (a: number, b: number) => number;
+export const rust_sqlite_wasm_localtime: (a: number) => number;
+export const rust_sqlite_wasm_realloc: (a: number, b: number) => number;
+export const sqlite3_os_end: () => number;
+export const sqlite3_os_init: () => number;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_export_4: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/dist/lazy-files.js

@@ -65,7 +65,13 @@ export class LazyExternalFileStore {
         const result = wasmGetExternalFile(this.buffer, fileId);
         if (!result)
             return null;
-        return result;
+        // WASM returns DucExternalFileEntry { key, value: DucExternalFileData }.
+        // Unwrap to get the actual file data.
+        const entry = result;
+        if (entry.value && typeof entry.value === "object") {
+            return entry.value;
+        }
+        return entry;
     }
     /** Fetch file data and return a copy of the data buffer (safe for transfer). */
     getFileDataCopy(fileId) {

package/dist/restore/restoreDataState.js

@@ -49,10 +49,15 @@ export const restoreFiles = (importedFiles) => {
     const files = importedFiles;
     for (const key in files) {
         if (Object.prototype.hasOwnProperty.call(files, key)) {
-            const fileData = files[key];
+            let fileData = files[key];
             if (!fileData || typeof fileData !== "object") {
                 continue;
             }
+            // Handle the nested DucExternalFileEntry structure { key, value: { ... } }
+            // produced by Rust serde or legacy exports.
+            if (fileData.value && typeof fileData.value === "object") {
+                fileData = fileData.value;
+            }
             const id = isValidExternalFileId(fileData.id);
             const mimeType = isValidString(fileData.mimeType);
             const created = isFiniteNumber(fileData.created)
@@ -805,6 +810,9 @@ export const isValidUint8Array = (value) => {
     if (value instanceof Uint8Array) {
         return value.byteLength > 0 ? value : undefined;
     }
+    if (value instanceof ArrayBuffer) {
+        return value.byteLength > 0 ? new Uint8Array(value) : undefined;
+    }
     if (typeof value === "string") {
         let base64String = value;
         if (value.startsWith("data:")) {

package/dist/technical/scopes.d.ts

@@ -9,7 +9,7 @@ export declare const MAX_ZOOM = 1e+32;
 export declare const NEUTRAL_SCOPE: SupportedMeasures;
 export declare const metricMeasures: readonly ["qm", "rm", "ym", "zm", "am", "fm", "pm", "Å", "nm", "µm", "mm", "cm", "dm", "m", "dam", "hm", "km", "Mm", "Gm", "Tm", "Pm", "Em", "Zm", "Ym", "Rm", "Qm"];
 export type MetricMeasure = typeof metricMeasures[number];
-export declare const imperialMeasures: readonly ["th", "ln", "in", "h", "ft", "yd", "rd", "ch", "fur", "mi", "lea"];
+export declare const imperialMeasures: readonly ["µin", "th", "mil", "ln", "in", "h", "ft", "yd", "rd", "ch", "fur", "mi", "lea", "au", "ly", "pc"];
 export type ImperialMeasure = typeof imperialMeasures[number];
 export type SupportedMeasures = MetricMeasure | ImperialMeasure;
 export type CombinedMeasure = SupportedMeasures;

package/dist/technical/scopes.js

@@ -32,7 +32,9 @@ export const metricMeasures = [
     'Qm', // Quettameter
 ];
 export const imperialMeasures = [
-    'th', // Thou/mil
+    'µin', // Microinches
+    'th', // Thou
+    'mil', // Mils
     'ln', // Line
     'in', // Inches
     'h', // Hand
@@ -43,6 +45,9 @@ export const imperialMeasures = [
     'fur', // Furlongs
     'mi', // Miles
     'lea', // Leagues
+    'au', // Astronomical Unit
+    'ly', // Light Year
+    'pc', // Parsec
 ];
 // Define metric units - exponents represent powers of 10
 export const metricUnits = [
@@ -76,17 +81,22 @@ export const metricUnits = [
 // Define imperial units - exponents are now relative to meter as the base unit
 // These values are log10 of their meter equivalents
 export const imperialUnits = [
-    { prefix: 'th', unit: 'thou', full: 'thou', exponent: -4.595 }, // log10(0.0000254) ≈ -4.595
-    { prefix: 'ln', unit: 'line', full: 'line', exponent: -2.674 }, // log10(0.00211667) ≈ -2.674 
-    { prefix: 'in', unit: 'inch', full: 'inch', exponent: -1.595 }, // log10(0.0254) ≈ -1.595
-    { prefix: 'h', unit: 'hand', full: 'hand', exponent: -0.993 }, // log10(0.1016) ≈ -0.993
-    { prefix: 'ft', unit: 'foot', full: 'foot', exponent: -0.516 }, // log10(0.3048) ≈ -0.516
-    { prefix: 'yd', unit: 'yard', full: 'yard', exponent: -0.039 }, // log10(0.9144) ≈ -0.039
-    { prefix: 'rd', unit: 'rod', full: 'rod', exponent: 0.701 }, // log10(5.0292) ≈ 0.701
-    { prefix: 'ch', unit: 'chain', full: 'chain', exponent: 1.304 }, // log10(20.1168) ≈ 1.304
-    { prefix: 'fur', unit: 'furlong', full: 'furlong', exponent: 2.304 }, // log10(201.168) ≈ 2.304
-    { prefix: 'mi', unit: 'mile', full: 'mile', exponent: 3.207 }, // log10(1609.344) ≈ 3.207
-    { prefix: 'lea', unit: 'league', full: 'league', exponent: 3.684 } // log10(4828.032) ≈ 3.684
+    { prefix: 'µin', unit: 'microinch', full: 'microinch', exponent: -7.595 }, // log10(2.54e-8)
+    { prefix: 'th', unit: 'thou', full: 'thou', exponent: -4.595 }, // log10(0.0000254)
+    { prefix: 'mil', unit: 'mil', full: 'mil', exponent: -4.595 }, // log10(0.0000254)
+    { prefix: 'ln', unit: 'line', full: 'line', exponent: -2.674 }, // log10(0.00211667)
+    { prefix: 'in', unit: 'inch', full: 'inch', exponent: -1.595 }, // log10(0.0254)
+    { prefix: 'h', unit: 'hand', full: 'hand', exponent: -0.993 }, // log10(0.1016)
+    { prefix: 'ft', unit: 'foot', full: 'foot', exponent: -0.516 }, // log10(0.3048)
+    { prefix: 'yd', unit: 'yard', full: 'yard', exponent: -0.039 }, // log10(0.9144)
+    { prefix: 'rd', unit: 'rod', full: 'rod', exponent: 0.701 }, // log10(5.0292)
+    { prefix: 'ch', unit: 'chain', full: 'chain', exponent: 1.304 }, // log10(20.1168)
+    { prefix: 'fur', unit: 'furlong', full: 'furlong', exponent: 2.304 }, // log10(201.168)
+    { prefix: 'mi', unit: 'mile', full: 'mile', exponent: 3.207 }, // log10(1609.344)
+    { prefix: 'lea', unit: 'league', full: 'league', exponent: 3.684 }, // log10(4828.032)
+    { prefix: 'au', unit: 'au', full: 'Astronomical Unit', exponent: 11.175 }, // log10(1.496e11)
+    { prefix: 'ly', unit: 'ly', full: 'Light Year', exponent: 15.976 }, // log10(9.461e15)
+    { prefix: 'pc', unit: 'pc', full: 'Parsec', exponent: 16.489 }, // log10(3.086e16)
 ];
 // Scale factors for unit conversions - using meter as the base unit
 export const ScaleFactors = {
@@ -118,7 +128,9 @@ export const ScaleFactors = {
     Rm: 1e27,
     Qm: 1e30,
     // Imperial scales
-    th: 0.0000254, // 0.001 inch
+    'µin': 2.54e-8, // Microinch
+    th: 0.0000254, // Thou (0.001 inch)
+    mil: 0.0000254, // Mil (same as Thou)
     ln: 0.00211667, // 1/12 inch
     in: 0.0254,
     h: 0.1016, // 4 inches
@@ -129,6 +141,9 @@ export const ScaleFactors = {
     fur: 201.168,
     mi: 1609.344,
     lea: 4828.032, // 3 miles
+    au: 149597870700, // Astronomical Unit
+    ly: 9460730472580800, // Light Year
+    pc: 30856775814913670, // Parsec
 };
 /**
  * Determines if a measure belongs to the metric system.

package/dist/wasm.d.ts

@@ -1,4 +1,4 @@
-import { getCurrentSchemaVersion as _getCurrentSchemaVersion, getExternalFile as _getExternalFile, listExternalFiles as _listExternalFiles, listVersions as _listVersions, parseDuc as _parseDuc, parseDucLazy as _parseDucLazy, readVersionGraph as _readVersionGraph, restoreCheckpoint as _restoreCheckpoint, restoreVersion as _restoreVersion, revertToVersion as _revertToVersion, serializeDuc as _serializeDuc } from "../pkg/ducjs_wasm";
+import { getCurrentSchemaVersion as _getCurrentSchemaVersion, getExternalFile as _getExternalFile, listExternalFiles as _listExternalFiles, listVersions as _listVersions, parseDuc as _parseDuc, parseDucLazy as _parseDucLazy, readVersionGraph as _readVersionGraph, restoreCheckpoint as _restoreCheckpoint, restoreVersion as _restoreVersion, revertToVersion as _revertToVersion, serializeDuc as _serializeDuc } from "../dist/ducjs_wasm";
 export declare function ensureWasm(wasmUrl?: string | URL | BufferSource): Promise<void>;
 /**
  * Fetch the raw WASM binary as an ArrayBuffer.

package/dist/wasm.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import init, { getCurrentSchemaVersion as _getCurrentSchemaVersion, getExternalFile as _getExternalFile, listExternalFiles as _listExternalFiles, listVersions as _listVersions, parseDuc as _parseDuc, parseDucLazy as _parseDucLazy, readVersionGraph as _readVersionGraph, restoreCheckpoint as _restoreCheckpoint, restoreVersion as _restoreVersion, revertToVersion as _revertToVersion, serializeDuc as _serializeDuc, } from "../pkg/ducjs_wasm";
+import init, { getCurrentSchemaVersion as _getCurrentSchemaVersion, getExternalFile as _getExternalFile, listExternalFiles as _listExternalFiles, listVersions as _listVersions, parseDuc as _parseDuc, parseDucLazy as _parseDucLazy, readVersionGraph as _readVersionGraph, restoreCheckpoint as _restoreCheckpoint, restoreVersion as _restoreVersion, revertToVersion as _revertToVersion, serializeDuc as _serializeDuc, } from "../dist/ducjs_wasm";
 let initialized = false;
 let initPromise = null;
 export function ensureWasm(wasmUrl) {
@@ -31,7 +31,7 @@ export function ensureWasm(wasmUrl) {
  */
 export function getWasmBinary() {
     return __awaiter(this, void 0, void 0, function* () {
-        const url = new URL('../pkg/ducjs_wasm_bg.wasm', import.meta.url);
+        const url = new URL('../dist/ducjs_wasm_bg.wasm', import.meta.url);
         const resp = yield fetch(url);
         if (!resp.ok) {
             throw new Error(`Failed to fetch WASM binary: ${resp.status} ${resp.statusText}`);

package/package.json

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