@ifc-lite/geometry 3.3.1 → 3.5.0

package/dist/wasm-runtime-trap.js

@@ -0,0 +1,134 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Classify WebAssembly runtime traps and, for the one case that genuinely
+ * cannot be recovered in-document, broadcast it so the host can offer a reload
+ * (#1898).
+ *
+ * A trap is what reaches JS when the engine executes `unreachable`: with
+ * `panic = "abort"` (rust/Cargo.toml) a Rust panic, a failed `assert!` and an
+ * allocator abort are ALL indistinguishable from here — see the same caveat in
+ * `huge-file-error.ts`. What a trap can damage is bounded: the wasm instance's
+ * linear memory keeps whatever the aborted call leaked, and any Rust state the
+ * call was mutating is left mid-flight. It does NOT invalidate the module, and
+ * it says nothing about other engine handles in the realm, let alone about
+ * other realms (each Worker instantiates its own `@ifc-lite/wasm`).
+ *
+ * So the recovery contract is:
+ *
+ *  - a trap taken inside an *operation* is the caller's failure. The bridge
+ *    that took it drops (and frees) its `IfcAPI` handle — that is where the
+ *    wedgeable per-load caches live — and the original trap propagates
+ *    unchanged. A later `init()`, on that bridge or any other, builds a fresh
+ *    handle and works.
+ *  - a trap taken while *initializing* means this realm could not produce a
+ *    working engine at all, and neither half of that is retryable in practice:
+ *    if the trap came from `new IfcAPI()` the module singleton is already built
+ *    and wasm-bindgen's `init()` will keep returning it, and if it came from
+ *    instantiation itself it is a deterministic module-level failure that
+ *    recurs. That is the only case that earns
+ *    {@link WASM_RUNTIME_UNRECOVERABLE_EVENT} — the user is told to reload,
+ *    which is the one thing that really does get a new instance.
+ *
+ * Even then nothing is latched: a later `init()` still tries, so the
+ * "unrecoverable" verdict is a diagnosis for the user, never a lock that could
+ * disable an unrelated consumer. Recovery is lazy — it happens on the next
+ * `init()` a consumer asks for — so there is no retry loop to bound either.
+ *
+ * Detection lives here as a pure, unit-testable predicate; the host app owns
+ * the reload policy and subscribes to the event. This library never reloads
+ * the page on its own — same division of labour as `wasm-asset-error.ts`.
+ */
+/**
+ * Stable marker in the message of the error thrown when the engine cannot be
+ * initialized after a trap. Kept in the message (not only in a field) so it
+ * survives the string-only round trip through error tracking, and so the host
+ * app can classify it without importing this package.
+ */
+export const WASM_RUNTIME_UNRECOVERABLE_CODE = 'WASM_RUNTIME_UNRECOVERABLE';
+/**
+ * Dispatched on `globalThis` when the WebAssembly geometry engine trapped
+ * while initializing and therefore cannot be rebuilt in this document.
+ * `detail.message` carries the originating trap text. Hosts that opt in tell
+ * the user to reload; unlike the version-skew event this must NOT trigger an
+ * automatic reload — a crash mid-session would discard the user's work.
+ */
+export const WASM_RUNTIME_UNRECOVERABLE_EVENT = 'ifclite:wasm-runtime-unrecoverable';
+function messageOf(err) {
+    if (err == null)
+        return '';
+    if (typeof err === 'string')
+        return err;
+    if (typeof err === 'object' && 'message' in err) {
+        const m = err.message;
+        if (typeof m === 'string')
+            return m;
+    }
+    return String(err);
+}
+/**
+ * True when `err` is a WebAssembly runtime trap.
+ *
+ * `instanceof WebAssembly.RuntimeError` alone is not enough: an error thrown
+ * inside a Worker/iframe realm and re-raised here fails the identity check
+ * because each realm has its own `WebAssembly.RuntimeError` constructor. The
+ * `.name` fallback is the cross-realm-safe half — `RuntimeError` is the class
+ * name the spec fixes for wasm traps, and structured-cloned errors keep it.
+ */
+export function isWasmRuntimeTrap(err) {
+    if (typeof WebAssembly !== 'undefined' && err instanceof WebAssembly.RuntimeError)
+        return true;
+    if (typeof err !== 'object' || err === null)
+        return false;
+    return err.name === 'RuntimeError';
+}
+/**
+ * True for the typed error {@link wasmRuntimeUnrecoverableError} produces —
+ * matched on the message marker so it also works on an error that only
+ * survived as text (an analytics payload, a `postMessage` hop).
+ */
+export function isWasmRuntimeUnrecoverableError(err) {
+    return messageOf(err).includes(WASM_RUNTIME_UNRECOVERABLE_CODE);
+}
+/**
+ * Build the error thrown when the engine trapped while initializing.
+ *
+ * Constructed FRESH at every throw site on purpose. The bug this replaces
+ * stored one Error object in a module global and rethrew it forever, so the
+ * stack shipped to error tracking pointed at whichever call first trapped —
+ * the production report for #1898 showed a `exportGlb` stack captured under a
+ * model-load context, which made it undiagnosable. The underlying trap is kept
+ * verbatim in the message tail (for triage from text alone) and as `.cause`
+ * (for programmatic inspection), mirroring `largeFilePrepassError`.
+ */
+export function wasmRuntimeUnrecoverableError(cause, operation) {
+    const raw = messageOf(cause) || String(cause);
+    return new Error(`${WASM_RUNTIME_UNRECOVERABLE_CODE}: the IFC-Lite WebAssembly geometry engine trapped during ` +
+        `${operation}, so this document has no working engine instance. Reload the page to get a ` +
+        `fresh one. (underlying wasm trap: ${raw})`, { cause });
+}
+function domDispatcher() {
+    const g = globalThis;
+    return typeof g.dispatchEvent === 'function' && typeof g.CustomEvent === 'function'
+        ? g
+        : null;
+}
+/**
+ * Broadcast {@link WASM_RUNTIME_UNRECOVERABLE_EVENT} on `globalThis` so an
+ * opted-in host can tell the user the engine is gone and offer a reload.
+ * No-op in non-DOM hosts such as Node (CLI/MCP), where the thrown error is the
+ * whole story.
+ */
+export function notifyWasmRuntimeUnrecoverable(err) {
+    const target = domDispatcher();
+    if (!target)
+        return;
+    try {
+        target.dispatchEvent(new CustomEvent(WASM_RUNTIME_UNRECOVERABLE_EVENT, { detail: { message: messageOf(err) } }));
+    }
+    catch {
+        /* CustomEvent unavailable — best effort, nothing more to do */
+    }
+}
+//# sourceMappingURL=wasm-runtime-trap.js.map

package/dist/wasm-runtime-trap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-runtime-trap.js","sourceRoot":"","sources":["../src/wasm-runtime-trap.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,4BAA4B,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,oCAAoC,CAAC;AAErF,SAAS,SAAS,CAAC,GAAY;IAC7B,IAAI,GAAG,IAAI,IAAI;QAAE,OAAO,EAAE,CAAC;IAC3B,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC;IACxC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,SAAS,IAAI,GAAG,EAAE,CAAC;QAChD,MAAM,CAAC,GAAI,GAA6B,CAAC,OAAO,CAAC;QACjD,IAAI,OAAO,CAAC,KAAK,QAAQ;YAAE,OAAO,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACrB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY;IAC5C,IAAI,OAAO,WAAW,KAAK,WAAW,IAAI,GAAG,YAAY,WAAW,CAAC,YAAY;QAAE,OAAO,IAAI,CAAC;IAC/F,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC1D,OAAQ,GAA0B,CAAC,IAAI,KAAK,cAAc,CAAC;AAC7D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAAC,GAAY;IAC1D,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,+BAA+B,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAAc,EAAE,SAAiB;IAC7E,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,OAAO,IAAI,KAAK,CACd,GAAG,+BAA+B,4DAA4D;QAC5F,GAAG,SAAS,8EAA8E;QAC1F,qCAAqC,GAAG,GAAG,EAC7C,EAAE,KAAK,EAAE,CACV,CAAC;AACJ,CAAC;AAMD,SAAS,aAAa;IACpB,MAAM,CAAC,GAAG,UAA2E,CAAC;IACtF,OAAO,OAAO,CAAC,CAAC,aAAa,KAAK,UAAU,IAAI,OAAO,CAAC,CAAC,WAAW,KAAK,UAAU;QACjF,CAAC,CAAE,CAAmB;QACtB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,8BAA8B,CAAC,GAAY;IACzD,MAAM,MAAM,GAAG,aAAa,EAAE,CAAC;IAC/B,IAAI,CAAC,MAAM;QAAE,OAAO;IACpB,IAAI,CAAC;QACH,MAAM,CAAC,aAAa,CAClB,IAAI,WAAW,CAAC,gCAAgC,EAAE,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAC3F,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,+DAA+D;IACjE,CAAC;AACH,CAAC"}

package/dist/wasm-shared-module.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Compile (or join the in-flight compile of) the engine binary for `explicitUrl`
+ * — or the default resolution when omitted.
+ *
+ * Resolves to `null` — the caller then leaves the consumer on its own `init()` —
+ * when the URL can't be resolved or compilation fails, so non-Vite consumers and
+ * offline/edge failures degrade to the previous behaviour rather than breaking.
+ */
+export declare function compileSharedWasmModule(explicitUrl?: string): Promise<WebAssembly.Module | null>;
+/**
+ * The compiled module for `explicitUrl` **only if a compile was already started**
+ * for it — otherwise `null`, without starting one.
+ *
+ * This is the "join, don't initiate" accessor for consumers that have their own
+ * working init path (`IfcLiteBridge.init()`): when a prewarm or a parallel load
+ * has already fetched the binary, reuse it; when nothing has, do exactly what
+ * this consumer did before rather than speculatively pulling 1.3 MB on a path
+ * that may not need it.
+ *
+ * Awaits an in-flight compile rather than racing it with a second fetch — the
+ * bytes are the same and already on the wire.
+ */
+export declare function getStartedSharedWasmModule(explicitUrl?: string): Promise<WebAssembly.Module | null> | null;
+/**
+ * Start the shared fetch+compile BEFORE a file is opened, so the binary is
+ * already downloaded and compiled by the time a load wants it.
+ *
+ * Without this the binary (~1.3 MB over the wire) is fetched lazily, on the
+ * click that opens a model: nothing overlaps the user's think time, and on a
+ * slow link the whole download sits in front of first geometry (measured 2.5 s
+ * on a ~4 Mbit connection, for a 225 KB model).
+ *
+ * Fire-and-forget by design: a prewarm failure must never surface to the user or
+ * poison the load path. `compileSharedWasmModule` already evicts a failed URL so
+ * the real load retries, and every consumer falls back to its own `init()` when
+ * no shared module is available. Callers decide *when* to call this (idle,
+ * intent) and whether the connection can afford it.
+ *
+ * `wasmUrl` MUST match the URL the subsequent load resolves — the memo is keyed
+ * on it, so prewarming one binary and loading another downloads both.
+ * Vite/webpack consumers (the viewer included) pass none and share the default
+ * resolution, which is the intended usage.
+ */
+export declare function prewarmSharedWasmModule(wasmUrl?: string): void;
+//# sourceMappingURL=wasm-shared-module.d.ts.map

package/dist/wasm-shared-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-shared-module.d.ts","sourceRoot":"","sources":["../src/wasm-shared-module.ts"],"names":[],"mappings":"AAoDA;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,CA0CpC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAK3C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAM9D"}

package/dist/wasm-shared-module.js

@@ -0,0 +1,155 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * ONE compiled `WebAssembly.Module` per binary per session, shared by every
+ * consumer of the geometry engine in this realm.
+ *
+ * Two independent code paths need the ~3.9 MB engine binary and used to fetch
+ * and compile it separately:
+ *   - the N-worker pool (`geometry-parallel.ts`), which structured-clones a
+ *     compiled module to each worker (#1818 — before that, N parallel compiles
+ *     of a multi-MB module contended on the CPU and produced a multi-second
+ *     "WASM ready" stagger before any geometry was meshed);
+ *   - the main-thread `IfcLiteBridge.init()` path, used by the adaptive sync
+ *     route for small files and by the export/bridge APIs, which calls
+ *     wasm-bindgen `init()` and lets IT fetch + compile.
+ *
+ * Keeping the memo here — rather than private to the worker pool — means the
+ * second path can reuse whatever the first already compiled, so the binary is
+ * fetched at most once per URL per realm no matter which path runs first. That
+ * matters most when the two overlap: a prewarm started at page load and a small
+ * file opened seconds later would otherwise be two concurrent downloads of the
+ * same 1.3 MB (browsers are not required to coalesce in-flight requests for the
+ * same URL), on exactly the slow connections the prewarm exists to help.
+ */
+// Keyed by the RESOLVED wasm URL, not a single global slot: federation / version
+// skew can load a DIFFERENT binary in the same session, and returning the first
+// compiled module for a later, incompatible URL would initialize the consumer's
+// wasm-bindgen glue against the wrong module. One promise per distinct binary.
+const sharedWasmModulePromises = new Map();
+function resolveWasmUrl(explicitUrl) {
+    if (explicitUrl)
+        return explicitUrl;
+    try {
+        // Source-aliased (Vite) build: the sibling `@ifc-lite/wasm` package's
+        // binary, resolved relative to THIS module. Vite statically rewrites this
+        // `new URL(..., import.meta.url)` to the emitted, content-hashed asset URL
+        // — the same asset the worker's wasm-bindgen glue resolves. In a plain
+        // tsc/npm build it resolves against dist/ and may 404, which the caller
+        // treats as "no shared module" and falls back to per-consumer init.
+        //
+        // NOTE: this specifier is relative to THIS FILE. It must stay in
+        // packages/geometry/src/ alongside its original home in
+        // geometry-parallel.ts, or Vite rewrites it to a different (404) asset.
+        return new URL('../../wasm/pkg/ifc-lite_bg.wasm', import.meta.url);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compile (or join the in-flight compile of) the engine binary for `explicitUrl`
+ * — or the default resolution when omitted.
+ *
+ * Resolves to `null` — the caller then leaves the consumer on its own `init()` —
+ * when the URL can't be resolved or compilation fails, so non-Vite consumers and
+ * offline/edge failures degrade to the previous behaviour rather than breaking.
+ */
+export async function compileSharedWasmModule(explicitUrl) {
+    if (typeof WebAssembly === 'undefined')
+        return null;
+    const url = resolveWasmUrl(explicitUrl);
+    if (!url)
+        return null;
+    const cacheKey = url instanceof URL ? url.href : url;
+    const cached = sharedWasmModulePromises.get(cacheKey);
+    if (cached)
+        return cached;
+    const p = (async () => {
+        try {
+            if (typeof WebAssembly.compileStreaming === 'function') {
+                try {
+                    // Compile WHILE the binary downloads (one streaming fetch + compile
+                    // for every consumer).
+                    return await WebAssembly.compileStreaming(fetch(url));
+                }
+                catch {
+                    // Some static hosts serve `.wasm` with the wrong MIME type, which
+                    // rejects compileStreaming — fall through to the buffer path.
+                }
+            }
+            const resp = await fetch(url);
+            if (!resp.ok)
+                return null;
+            return await WebAssembly.compile(await resp.arrayBuffer());
+        }
+        catch (err) {
+            console.warn('[stream] shared wasm compile failed; consumers will self-init:', err);
+            return null;
+        }
+    })();
+    sharedWasmModulePromises.set(cacheKey, p);
+    const result = await p;
+    // Don't cache a failure — evict ONLY this URL's entry so the next load retries
+    // (a transient fetch error shouldn't permanently disable the shared-module fast
+    // path for the session), while other URLs' successful modules stay cached.
+    //
+    // Evict only if THIS promise is still the installed one. A failed compile can
+    // have several awaiters; the first to resume evicts and a retry may install a
+    // fresh promise before the rest resume. Without the identity check those late
+    // awaiters would delete the *replacement*, breaking single-flight and letting
+    // a second compile of the same binary start.
+    if (result === null && sharedWasmModulePromises.get(cacheKey) === p) {
+        sharedWasmModulePromises.delete(cacheKey);
+    }
+    return result;
+}
+/**
+ * The compiled module for `explicitUrl` **only if a compile was already started**
+ * for it — otherwise `null`, without starting one.
+ *
+ * This is the "join, don't initiate" accessor for consumers that have their own
+ * working init path (`IfcLiteBridge.init()`): when a prewarm or a parallel load
+ * has already fetched the binary, reuse it; when nothing has, do exactly what
+ * this consumer did before rather than speculatively pulling 1.3 MB on a path
+ * that may not need it.
+ *
+ * Awaits an in-flight compile rather than racing it with a second fetch — the
+ * bytes are the same and already on the wire.
+ */
+export function getStartedSharedWasmModule(explicitUrl) {
+    const url = resolveWasmUrl(explicitUrl);
+    if (!url)
+        return null;
+    const cacheKey = url instanceof URL ? url.href : url;
+    return sharedWasmModulePromises.get(cacheKey) ?? null;
+}
+/**
+ * Start the shared fetch+compile BEFORE a file is opened, so the binary is
+ * already downloaded and compiled by the time a load wants it.
+ *
+ * Without this the binary (~1.3 MB over the wire) is fetched lazily, on the
+ * click that opens a model: nothing overlaps the user's think time, and on a
+ * slow link the whole download sits in front of first geometry (measured 2.5 s
+ * on a ~4 Mbit connection, for a 225 KB model).
+ *
+ * Fire-and-forget by design: a prewarm failure must never surface to the user or
+ * poison the load path. `compileSharedWasmModule` already evicts a failed URL so
+ * the real load retries, and every consumer falls back to its own `init()` when
+ * no shared module is available. Callers decide *when* to call this (idle,
+ * intent) and whether the connection can afford it.
+ *
+ * `wasmUrl` MUST match the URL the subsequent load resolves — the memo is keyed
+ * on it, so prewarming one binary and loading another downloads both.
+ * Vite/webpack consumers (the viewer included) pass none and share the default
+ * resolution, which is the intended usage.
+ */
+export function prewarmSharedWasmModule(wasmUrl) {
+    void compileSharedWasmModule(wasmUrl).catch((err) => {
+        // Unreachable in practice — compileSharedWasmModule swallows its own
+        // failures and resolves null — but never let a prewarm reject unhandled.
+        console.warn('[stream] wasm prewarm failed; load path will retry:', err);
+    });
+}
+//# sourceMappingURL=wasm-shared-module.js.map

package/dist/wasm-shared-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-shared-module.js","sourceRoot":"","sources":["../src/wasm-shared-module.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,iFAAiF;AACjF,gFAAgF;AAChF,gFAAgF;AAChF,+EAA+E;AAC/E,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAA8C,CAAC;AAEvF,SAAS,cAAc,CAAC,WAAoB;IAC1C,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC;IACpC,IAAI,CAAC;QACH,sEAAsE;QACtE,0EAA0E;QAC1E,2EAA2E;QAC3E,uEAAuE;QACvE,wEAAwE;QACxE,oEAAoE;QACpE,EAAE;QACF,iEAAiE;QACjE,wDAAwD;QACxD,wEAAwE;QACxE,OAAO,IAAI,GAAG,CAAC,iCAAiC,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,WAAoB;IAEpB,IAAI,OAAO,WAAW,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IACpD,MAAM,GAAG,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;IACxC,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,QAAQ,GAAG,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;IACrD,MAAM,MAAM,GAAG,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtD,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAC1B,MAAM,CAAC,GAAG,CAAC,KAAK,IAAwC,EAAE;QACxD,IAAI,CAAC;YACH,IAAI,OAAO,WAAW,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;gBACvD,IAAI,CAAC;oBACH,oEAAoE;oBACpE,uBAAuB;oBACvB,OAAO,MAAM,WAAW,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBACxD,CAAC;gBAAC,MAAM,CAAC;oBACP,kEAAkE;oBAClE,8DAA8D;gBAChE,CAAC;YACH,CAAC;YACD,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,EAAE;gBAAE,OAAO,IAAI,CAAC;YAC1B,OAAO,MAAM,WAAW,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QAC7D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,gEAAgE,EAAE,GAAG,CAAC,CAAC;YACpF,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IACL,wBAAwB,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC;IACvB,+EAA+E;IAC/E,gFAAgF;IAChF,2EAA2E;IAC3E,EAAE;IACF,8EAA8E;IAC9E,8EAA8E;IAC9E,8EAA8E;IAC9E,8EAA8E;IAC9E,6CAA6C;IAC7C,IAAI,MAAM,KAAK,IAAI,IAAI,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACpE,wBAAwB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,0BAA0B,CACxC,WAAoB;IAEpB,MAAM,GAAG,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;IACxC,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,QAAQ,GAAG,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;IACrD,OAAO,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAgB;IACtD,KAAK,uBAAuB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;QAClD,qEAAqE;QACrE,yEAAyE;QACzE,OAAO,CAAC,IAAI,CAAC,qDAAqD,EAAE,GAAG,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/geometry",
-  "version": "3.3.1",
+  "version": "3.5.0",
   "description": "Geometry processing bridge for IFC-Lite - exact-arithmetic CSG, streamed across workers",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,8 +13,8 @@
     }
   },
   "dependencies": {
-    "@ifc-lite/data": "^2.8.0",
-    "@ifc-lite/wasm": "^4.1.3"
+    "@ifc-lite/data": "^3.0.0",
+    "@ifc-lite/wasm": "^4.2.0"
   },
   "optionalDependencies": {
     "@tauri-apps/api": "^2.11.1"