@ifc-lite/viewer 1.17.2 → 1.17.3

package/dist/assets/server-client-D3bUPJJc.js

@@ -0,0 +1,626 @@
+import { _ as de, __tla as __tla_0 } from "./exporters-C_6J153K.js";
+let We, je;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    let Ae = !1, fe = null;
+    async function _e() {
+        if (Ae && fe) return fe;
+        console.log("[parquet-decoder] Starting WASM initialization...");
+        let n;
+        try {
+            if (n = await de(()=>import("./parquet-CEXmQNRO.js").then((e)=>e.a), []), console.log("[parquet-decoder] Imported ESM build"), typeof n.default == "function") {
+                console.log("[parquet-decoder] Calling ESM init to load WASM...");
+                const o = (await de(()=>import("./parquet-CEXmQNRO.js").then((r)=>r.b), [])).default;
+                console.log("[parquet-decoder] Loading WASM from:", o), await n.default(o), console.log("[parquet-decoder] ESM WASM initialized");
+            }
+            if (typeof n.readParquet == "function") return fe = n, Ae = !0, console.log("[parquet-decoder] ESM build ready with readParquet"), n;
+            console.warn("[parquet-decoder] ESM build initialized but readParquet not found");
+        } catch (e) {
+            console.warn("[parquet-decoder] ESM import failed:", e);
+        }
+        try {
+            if (n = await de(()=>import("./parquet-CEXmQNRO.js").then((e)=>e.a), []), typeof n.default == "function") {
+                console.log("[parquet-decoder] Trying web init with node_modules path...");
+                const e = [
+                    "/node_modules/parquet-wasm/esm/arrow2_bg.wasm",
+                    "./node_modules/parquet-wasm/esm/arrow2_bg.wasm"
+                ];
+                for (const o of e)try {
+                    const r = await fetch(o);
+                    if (r.ok && (console.log("[parquet-decoder] Found WASM at:", o), await n.default(r), typeof n.readParquet == "function")) return fe = n, Ae = !0, console.log("[parquet-decoder] Web init successful"), n;
+                } catch  {}
+            }
+        } catch (e) {
+            console.warn("[parquet-decoder] Web init failed:", e);
+        }
+        throw new Error("parquet-wasm: Could not load WASM module. Ensure parquet-wasm is installed and WASM files are accessible.");
+    }
+    async function ve(n) {
+        const e = await _e(), o = new DataView(n);
+        let r = 0;
+        const a = o.getUint32(r, !0);
+        r += 4;
+        const t = new Uint8Array(n, r, a);
+        r += a;
+        const i = o.getUint32(r, !0);
+        r += 4;
+        const l = new Uint8Array(n, r, i);
+        r += i;
+        const c = o.getUint32(r, !0);
+        r += 4;
+        const m = new Uint8Array(n, r, c), y = e.readParquet(t), f = e.readParquet(l), b = e.readParquet(m), u = await de(()=>import("./arrow-DJf2ErbF.js").then((_)=>_.A), []), d = u.tableFromIPC(y.intoIPCStream()), q = u.tableFromIPC(f.intoIPCStream()), $ = u.tableFromIPC(b.intoIPCStream()), E = d.getChild("express_id")?.toArray(), C = d.getChild("ifc_type"), S = d.getChild("vertex_start")?.toArray(), F = d.getChild("vertex_count")?.toArray(), T = d.getChild("index_start")?.toArray(), x = d.getChild("index_count")?.toArray(), D = d.getChild("color_r")?.toArray(), I = d.getChild("color_g")?.toArray(), v = d.getChild("color_b")?.toArray(), P = d.getChild("color_a")?.toArray(), w = q.getChild("x")?.toArray(), K = q.getChild("y")?.toArray(), N = q.getChild("z")?.toArray(), z = q.getChild("nx")?.toArray(), G = q.getChild("ny")?.toArray(), R = q.getChild("nz")?.toArray(), X = $.getChild("i0")?.toArray(), O = $.getChild("i1")?.toArray(), H = $.getChild("i2")?.toArray(), ae = E.length, L = new Array(ae);
+        for(let _ = 0; _ < ae; _++){
+            const ne = S[_], J = F[_], me = T[_], se = x[_], Y = new Float32Array(J * 3);
+            for(let h = 0; h < J; h++){
+                const g = ne + h;
+                Y[h * 3] = w[g], Y[h * 3 + 1] = K[g], Y[h * 3 + 2] = N[g];
+            }
+            const k = new Float32Array(J * 3);
+            for(let h = 0; h < J; h++){
+                const g = ne + h;
+                k[h * 3] = z[g], k[h * 3 + 1] = G[g], k[h * 3 + 2] = R[g];
+            }
+            const ie = se / 3, Z = me / 3, V = new Uint32Array(se);
+            for(let h = 0; h < ie; h++){
+                const g = Z + h;
+                V[h * 3] = X[g], V[h * 3 + 1] = O[g], V[h * 3 + 2] = H[g];
+            }
+            L[_] = {
+                express_id: E[_],
+                ifc_type: C?.get(_) ?? "Unknown",
+                positions: Y,
+                normals: k,
+                indices: V,
+                color: [
+                    D[_],
+                    I[_],
+                    v[_],
+                    P[_]
+                ]
+            };
+        }
+        return L;
+    }
+    async function ge() {
+        try {
+            return await _e(), !0;
+        } catch (n) {
+            return console.warn("[parquet-decoder] Parquet WASM initialization failed:", n), !1;
+        }
+    }
+    async function Re(n, e = 1e4) {
+        const o = await _e(), r = await de(()=>import("./arrow-DJf2ErbF.js").then((M)=>M.A), []), a = new DataView(n);
+        let t = 0;
+        const i = a.getUint8(t);
+        if (t += 1, i !== 2) throw new Error(`Unsupported optimized Parquet version: ${i}`);
+        const l = a.getUint8(t);
+        t += 1;
+        const c = (l & 1) !== 0, m = a.getUint32(t, !0);
+        t += 4;
+        const y = a.getUint32(t, !0);
+        t += 4;
+        const f = a.getUint32(t, !0);
+        t += 4;
+        const b = a.getUint32(t, !0);
+        t += 4;
+        const u = a.getUint32(t, !0);
+        t += 4;
+        const d = new Uint8Array(n, t, m);
+        t += m;
+        const q = new Uint8Array(n, t, y);
+        t += y;
+        const $ = new Uint8Array(n, t, f);
+        t += f;
+        const E = new Uint8Array(n, t, b);
+        t += b;
+        const C = new Uint8Array(n, t, u), S = o.readParquet(d), F = o.readParquet(q), T = o.readParquet($), x = o.readParquet(E), D = o.readParquet(C), I = r.tableFromIPC(S.intoIPCStream()), v = r.tableFromIPC(F.intoIPCStream()), P = r.tableFromIPC(T.intoIPCStream()), w = r.tableFromIPC(x.intoIPCStream()), K = r.tableFromIPC(D.intoIPCStream()), N = I.getChild("entity_id")?.toArray(), z = I.getChild("ifc_type"), G = I.getChild("mesh_index")?.toArray(), R = I.getChild("material_index")?.toArray(), X = v.getChild("vertex_offset")?.toArray(), O = v.getChild("vertex_count")?.toArray(), H = v.getChild("index_offset")?.toArray(), ae = v.getChild("index_count")?.toArray(), L = P.getChild("r")?.toArray(), _ = P.getChild("g")?.toArray(), ne = P.getChild("b")?.toArray(), J = P.getChild("a")?.toArray(), me = w.getChild("x")?.toArray(), se = w.getChild("y")?.toArray(), Y = w.getChild("z")?.toArray(), k = c ? w.getChild("nx")?.toArray() : null, ie = c ? w.getChild("ny")?.toArray() : null, Z = c ? w.getChild("nz")?.toArray() : null, V = K.getChild("i")?.toArray(), h = N.length, g = new Array(h), p = 1 / e;
+        for(let M = 0; M < h; M++){
+            const ce = G[M], ee = R[M], pe = X[ce], te = O[ce], he = H[ce], le = ae[ce], re = new Float32Array(te * 3);
+            for(let A = 0; A < te; A++){
+                const W = pe + A;
+                re[A * 3] = me[W] * p, re[A * 3 + 1] = se[W] * p, re[A * 3 + 2] = Y[W] * p;
+            }
+            let B;
+            if (c && k && ie && Z) {
+                B = new Float32Array(te * 3);
+                for(let A = 0; A < te; A++){
+                    const W = pe + A;
+                    B[A * 3] = k[W], B[A * 3 + 1] = ie[W], B[A * 3 + 2] = Z[W];
+                }
+            } else B = Ve(re, V.slice(he, he + le));
+            const ue = new Uint32Array(le);
+            for(let A = 0; A < le; A++)ue[A] = V[he + A];
+            g[M] = {
+                express_id: N[M],
+                ifc_type: z?.get(M) ?? "Unknown",
+                positions: re,
+                normals: B,
+                indices: ue,
+                color: [
+                    L[ee] / 255,
+                    _[ee] / 255,
+                    ne[ee] / 255,
+                    J[ee] / 255
+                ]
+            };
+        }
+        return g;
+    }
+    function Ve(n, e) {
+        const o = n.length / 3, r = new Float32Array(o * 3).fill(0), a = e.length / 3;
+        for(let t = 0; t < a; t++){
+            const i = e[t * 3], l = e[t * 3 + 1], c = e[t * 3 + 2], m = n[i * 3], y = n[i * 3 + 1], f = n[i * 3 + 2], b = n[l * 3], u = n[l * 3 + 1], d = n[l * 3 + 2], q = n[c * 3], $ = n[c * 3 + 1], E = n[c * 3 + 2], C = b - m, S = u - y, F = d - f, T = q - m, x = $ - y, D = E - f, I = S * D - F * x, v = F * T - C * D, P = C * x - S * T;
+            r[i * 3] += I, r[i * 3 + 1] += v, r[i * 3 + 2] += P, r[l * 3] += I, r[l * 3 + 1] += v, r[l * 3 + 2] += P, r[c * 3] += I, r[c * 3 + 1] += v, r[c * 3 + 2] += P;
+        }
+        for(let t = 0; t < o; t++){
+            const i = r[t * 3], l = r[t * 3 + 1], c = r[t * 3 + 2], m = Math.sqrt(i * i + l * l + c * c);
+            m > 0 && (r[t * 3] /= m, r[t * 3 + 1] /= m, r[t * 3 + 2] /= m);
+        }
+        return r;
+    }
+    async function be(n) {
+        const e = n instanceof File ? n.stream() : new Blob([
+            n
+        ]).stream(), o = new CompressionStream("gzip"), r = e.pipeThrough(o);
+        return new Response(r).blob();
+    }
+    async function Fe(n) {
+        const e = n instanceof File ? await n.arrayBuffer() : n, o = await crypto.subtle.digest("SHA-256", e);
+        return Array.from(new Uint8Array(o)).map((r)=>r.toString(16).padStart(2, "0")).join("");
+    }
+    We = class {
+        constructor(e){
+            this.baseUrl = e.baseUrl.replace(/\/$/, ""), this.timeout = e.timeout ?? 3e5;
+        }
+        async health() {
+            const e = await fetch(`${this.baseUrl}/api/v1/health`, {
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (!e.ok) throw await this.handleError(e);
+            return e.json();
+        }
+        async parse(e) {
+            const o = await be(e), r = e instanceof File ? e.name : "model.ifc", a = new FormData;
+            a.append("file", o, r);
+            const t = await fetch(`${this.baseUrl}/api/v1/parse`, {
+                method: "POST",
+                body: a,
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (!t.ok) throw await this.handleError(t);
+            return t.json();
+        }
+        async parseParquet(e) {
+            if (!await ge()) throw new Error("Parquet parsing requires parquet-wasm and apache-arrow. Install them with: npm install parquet-wasm apache-arrow");
+            const r = performance.now(), a = await Fe(e), t = performance.now() - r;
+            console.log(`[client] Computed file hash in ${t.toFixed(0)}ms: ${a.substring(0, 16)}...`);
+            const i = performance.now(), l = await fetch(`${this.baseUrl}/api/v1/cache/check/${a}`, {
+                method: "GET",
+                signal: AbortSignal.timeout(5e3)
+            }), c = performance.now() - i;
+            return l.ok ? (console.log(`[client] Cache HIT (check: ${c.toFixed(0)}ms) - skipping upload`), this.fetchCachedGeometry(a)) : (console.log(`[client] Cache MISS (check: ${c.toFixed(0)}ms) - uploading file`), this.uploadAndProcessParquet(e, a));
+        }
+        async parseParquetStream(e, o) {
+            if (!await ge()) throw new Error("Parquet streaming requires parquet-wasm and apache-arrow. Install them with: npm install parquet-wasm apache-arrow");
+            const a = e instanceof File ? e.size : e.byteLength, t = e instanceof File ? e.name : "model.ifc", i = performance.now(), l = await Fe(e), c = performance.now() - i;
+            console.log(`[client] Stream: computed hash in ${c.toFixed(0)}ms: ${l.substring(0, 16)}...`);
+            const m = performance.now(), y = await fetch(`${this.baseUrl}/api/v1/cache/check/${l}`, {
+                method: "GET",
+                signal: AbortSignal.timeout(5e3)
+            }), f = performance.now() - m;
+            if (y.ok) {
+                console.log(`[client] Stream: Cache HIT (check: ${f.toFixed(0)}ms) - fetching cached geometry`);
+                const x = await this.fetchCachedGeometry(l), D = performance.now();
+                return o({
+                    meshes: x.meshes,
+                    batch_number: 1,
+                    decode_time_ms: performance.now() - D
+                }), {
+                    cache_key: x.cache_key,
+                    total_meshes: x.meshes.length,
+                    stats: x.stats,
+                    metadata: x.metadata
+                };
+            }
+            console.log(`[client] Stream: Cache MISS (check: ${f.toFixed(0)}ms) - starting stream for ${t} (${(a / 1024 / 1024).toFixed(1)}MB)`);
+            const b = new FormData;
+            b.append("file", e instanceof File ? e : new Blob([
+                e
+            ]), t);
+            const u = performance.now(), d = await fetch(`${this.baseUrl}/api/v1/parse/parquet-stream`, {
+                method: "POST",
+                body: b,
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (!d.ok) throw await this.handleError(d);
+            if (!d.body) throw new Error("No response body for streaming");
+            const q = d.body.getReader(), $ = new TextDecoder;
+            let E = "", C = "", S = 0, F = null, T = null;
+            for(;;){
+                const { done: x, value: D } = await q.read();
+                if (x) break;
+                E += $.decode(D, {
+                    stream: !0
+                });
+                const I = E.split(`
+`);
+                E = I.pop() || "";
+                for (const v of I){
+                    if (!v.startsWith("data:")) continue;
+                    const P = v.slice(5).trim();
+                    if (P) try {
+                        const w = JSON.parse(P);
+                        switch(w.type){
+                            case "start":
+                                C = w.cache_key, console.log(`[client] Stream started: ${w.total_estimate} entities, cache_key: ${C.substring(0, 16)}...`);
+                                break;
+                            case "progress":
+                                break;
+                            case "batch":
+                                {
+                                    const N = performance.now(), z = atob(w.data), G = new Uint8Array(z.length);
+                                    for(let O = 0; O < z.length; O++)G[O] = z.charCodeAt(O);
+                                    const R = await ve(G.buffer), X = performance.now() - N;
+                                    S += R.length, console.log(`[client] Batch #${w.batch_number}: ${R.length} meshes, decode: ${X.toFixed(0)}ms`), o({
+                                        meshes: R,
+                                        batch_number: w.batch_number,
+                                        decode_time_ms: X
+                                    });
+                                    break;
+                                }
+                            case "complete":
+                                F = w.stats, T = w.metadata;
+                                const K = performance.now() - u;
+                                console.log(`[client] Stream complete: ${S} meshes in ${K.toFixed(0)}ms`);
+                                break;
+                            case "error":
+                                throw new Error(`Stream error: ${w.message}`);
+                        }
+                    } catch (w) {
+                        if (w instanceof SyntaxError) console.warn("[client] Failed to parse SSE event:", P);
+                        else throw w;
+                    }
+                }
+            }
+            if (!F || !T) throw new Error("Stream ended without complete event");
+            return {
+                cache_key: C,
+                total_meshes: S,
+                stats: F,
+                metadata: T
+            };
+        }
+        async fetchCachedGeometry(e) {
+            const o = performance.now(), r = await fetch(`${this.baseUrl}/api/v1/cache/geometry/${e}`, {
+                method: "GET",
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (!r.ok) throw await this.handleError(r);
+            const a = performance.now() - o;
+            console.log(`[client] Fetched cached geometry in ${a.toFixed(0)}ms`);
+            const t = r.headers.get("X-IFC-Metadata");
+            if (!t) throw new Error("Missing X-IFC-Metadata header in cached geometry response");
+            const i = JSON.parse(t), l = await r.arrayBuffer(), c = l.byteLength;
+            return this.parseParquetResponse(l, i, c);
+        }
+        async uploadAndProcessParquet(e, o) {
+            const r = e instanceof File ? e.size : e.byteLength, a = e instanceof File ? e.name : "model.ifc", t = this.baseUrl.includes("localhost") || this.baseUrl.includes("127.0.0.1"), i = r > 50 * 1024 * 1024 || t;
+            let l;
+            if (i) console.log(`[client] Skipping compression (file: ${(r / 1024 / 1024).toFixed(1)}MB, localhost: ${t})`), l = e instanceof File ? e : new Blob([
+                e
+            ]);
+            else {
+                const $ = performance.now();
+                l = await be(e), console.log(`[client] Compressed in ${(performance.now() - $).toFixed(0)}ms: ${(r / 1024 / 1024).toFixed(1)}MB → ${(l.size / 1024 / 1024).toFixed(1)}MB`);
+            }
+            const c = new FormData;
+            c.append("file", l, a);
+            const m = performance.now(), y = await fetch(`${this.baseUrl}/api/v1/parse/parquet`, {
+                method: "POST",
+                body: c,
+                signal: AbortSignal.timeout(this.timeout)
+            }), f = performance.now() - m;
+            if (console.log(`[client] Upload and processing completed in ${f.toFixed(0)}ms`), !y.ok) throw await this.handleError(y);
+            const b = y.headers.get("X-IFC-Metadata");
+            if (!b) throw new Error("Missing X-IFC-Metadata header in Parquet response");
+            const u = JSON.parse(b);
+            u.cache_key !== o && console.warn(`[client] Cache key mismatch: expected ${o.substring(0, 16)}..., got ${u.cache_key.substring(0, 16)}...`);
+            const d = await y.arrayBuffer(), q = d.byteLength;
+            return this.parseParquetResponse(d, u, q);
+        }
+        async parseParquetResponse(e, o, r) {
+            const a = new DataView(e);
+            let t = 0;
+            const i = a.getUint32(0, !0), l = i > 0 && i < e.byteLength && i < e.byteLength - 4;
+            let c, m;
+            if (l) {
+                const u = i;
+                if (t += 4, u > e.byteLength || u === 0 || t + u > e.byteLength) throw new Error(`Invalid geometry length: ${u}, buffer size: ${e.byteLength}, offset: ${t}`);
+                if (c = e.slice(t, t + u), t += u, t < e.byteLength) {
+                    const d = a.getUint32(t, !0);
+                    t += 4, d > 0 && t + d <= e.byteLength && (m = e.slice(t, t + d));
+                }
+            } else console.log("[client] Detected old format (no wrapper), using entire payload as geometry"), c = e, m = void 0;
+            const y = performance.now(), f = await ve(c), b = performance.now() - y;
+            return {
+                cache_key: o.cache_key,
+                meshes: f,
+                mesh_coordinate_space: o.mesh_coordinate_space,
+                site_transform: o.site_transform,
+                building_transform: o.building_transform,
+                metadata: o.metadata,
+                stats: o.stats,
+                parquet_stats: {
+                    payload_size: r,
+                    decode_time_ms: Math.round(b)
+                },
+                data_model: m
+            };
+        }
+        async fetchDataModel(e, o = 10) {
+            let r = 100;
+            for(let a = 0; a < o; a++)try {
+                const t = await fetch(`${this.baseUrl}/api/v1/parse/data-model/${e}`, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(3e4)
+                });
+                if (t.status === 200) {
+                    const i = await t.arrayBuffer();
+                    return console.log(`[client] Data model fetched: ${(i.byteLength / 1024 / 1024).toFixed(2)}MB`), i;
+                } else if (t.status === 202) console.log(`[client] Data model still processing (attempt ${a + 1}/${o}), waiting ${r}ms...`), await new Promise((i)=>setTimeout(i, r)), r = Math.min(r * 1.5, 2e3);
+                else {
+                    if (t.status === 404) return console.warn(`[client] Data model not found for cache key: ${e}`), null;
+                    throw new Error(`Unexpected response status: ${t.status}`);
+                }
+            } catch (t) {
+                if (a === o - 1) return console.error("[client] Failed to fetch data model:", t), null;
+                await new Promise((i)=>setTimeout(i, r)), r = Math.min(r * 1.5, 2e3);
+            }
+            return console.warn("[client] Data model fetch timed out after max retries"), null;
+        }
+        async isParquetSupported() {
+            return ge();
+        }
+        async parseParquetOptimized(e) {
+            if (!await ge()) throw new Error("Parquet parsing requires parquet-wasm and apache-arrow. Install them with: npm install parquet-wasm apache-arrow");
+            const r = await be(e), a = e instanceof File ? e.name : "model.ifc", t = new FormData;
+            t.append("file", r, a);
+            const i = await fetch(`${this.baseUrl}/api/v1/parse/parquet/optimized`, {
+                method: "POST",
+                body: t,
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (!i.ok) throw await this.handleError(i);
+            const l = i.headers.get("X-IFC-Metadata");
+            if (!l) throw new Error("Missing X-IFC-Metadata header in optimized Parquet response");
+            const c = JSON.parse(l), m = await i.arrayBuffer(), y = m.byteLength, f = performance.now(), b = await Re(m, c.vertex_multiplier), u = performance.now() - f;
+            return {
+                cache_key: c.cache_key,
+                meshes: b,
+                mesh_coordinate_space: c.mesh_coordinate_space,
+                site_transform: c.site_transform,
+                building_transform: c.building_transform,
+                metadata: c.metadata,
+                stats: c.stats,
+                optimization_stats: c.optimization_stats,
+                parquet_stats: {
+                    payload_size: y,
+                    decode_time_ms: Math.round(u)
+                }
+            };
+        }
+        async *parseStream(e) {
+            const o = new FormData, r = e instanceof File ? e : new Blob([
+                e
+            ], {
+                type: "application/octet-stream"
+            });
+            o.append("file", r, e instanceof File ? e.name : "model.ifc");
+            const a = await fetch(`${this.baseUrl}/api/v1/parse/stream`, {
+                method: "POST",
+                body: o,
+                headers: {
+                    Accept: "text/event-stream"
+                }
+            });
+            if (!a.ok) throw await this.handleError(a);
+            if (!a.body) throw new Error("Response body is null");
+            const t = a.body.getReader(), i = new TextDecoder;
+            let l = "";
+            try {
+                for(;;){
+                    const { done: c, value: m } = await t.read();
+                    if (c) break;
+                    l += i.decode(m, {
+                        stream: !0
+                    });
+                    const y = l.split(`
+
+`);
+                    l = y.pop() || "";
+                    for (const f of y)if (f.startsWith("data: ")) try {
+                        yield JSON.parse(f.slice(6));
+                    } catch  {}
+                }
+                if (l.startsWith("data: ")) try {
+                    yield JSON.parse(l.slice(6));
+                } catch  {}
+            } finally{
+                t.releaseLock();
+            }
+        }
+        async getMetadata(e) {
+            const o = new FormData;
+            o.append("file", e instanceof File ? e : new Blob([
+                e
+            ]), e instanceof File ? e.name : "model.ifc");
+            const r = await fetch(`${this.baseUrl}/api/v1/parse/metadata`, {
+                method: "POST",
+                body: o,
+                signal: AbortSignal.timeout(3e4)
+            });
+            if (!r.ok) throw await this.handleError(r);
+            return r.json();
+        }
+        async getCached(e) {
+            const o = await fetch(`${this.baseUrl}/api/v1/cache/${e}`, {
+                signal: AbortSignal.timeout(this.timeout)
+            });
+            if (o.status === 404) return null;
+            if (!o.ok) throw await this.handleError(o);
+            return o.json();
+        }
+        async handleError(e) {
+            try {
+                const o = await e.json();
+                return new Error(`Server error (${o.code}): ${o.error}`);
+            } catch  {
+                return new Error(`Server error: ${e.status} ${e.statusText}`);
+            }
+        }
+    };
+    je = async function(n) {
+        const e = await _e(), o = await de(()=>import("./arrow-DJf2ErbF.js").then((s)=>s.A), []), r = new DataView(n);
+        let a = 0;
+        const t = r.getUint32(a, !0);
+        a += 4;
+        const i = new Uint8Array(n, a, t);
+        a += t;
+        const l = r.getUint32(a, !0);
+        a += 4;
+        const c = new Uint8Array(n, a, l);
+        a += l;
+        const m = r.getUint32(a, !0);
+        a += 4;
+        const y = new Uint8Array(n, a, m);
+        a += m;
+        const f = r.getUint32(a, !0);
+        a += 4;
+        const b = new Uint8Array(n, a, f);
+        a += f;
+        const u = r.getUint32(a, !0);
+        a += 4;
+        const d = new Uint8Array(n, a, u), q = e.readParquet(i), $ = e.readParquet(c), E = e.readParquet(b), C = o.tableFromIPC(q.intoIPCStream()), S = o.tableFromIPC($.intoIPCStream()), F = o.tableFromIPC(E.intoIPCStream()), T = C.getChild("entity_id")?.toArray(), x = C.getChild("has_geometry")?.toArray(), D = C.getChild("type_name")?.toArray(), I = C.getChild("global_id")?.toArray(), v = C.getChild("name")?.toArray(), P = C.getChild("description")?.toArray(), w = C.getChild("object_type")?.toArray(), K = T.length, N = new Map;
+        for(let s = 0; s < K; s++)N.set(T[s], {
+            entity_id: T[s],
+            type_name: D[s] ?? "",
+            global_id: I[s] || void 0,
+            name: v[s] || void 0,
+            description: P?.[s] || void 0,
+            object_type: w?.[s] || void 0,
+            has_geometry: x[s] !== 0
+        });
+        const z = S.getChild("pset_id")?.toArray(), G = S.getChild("pset_name")?.toArray(), R = S.getChild("property_name")?.toArray(), X = S.getChild("property_value")?.toArray(), O = S.getChild("property_type")?.toArray(), H = new Map;
+        for(let s = 0; s < z.length; s++){
+            const U = z[s];
+            H.has(U) || H.set(U, {
+                pset_id: U,
+                pset_name: G[s] ?? "",
+                properties: []
+            }), H.get(U).properties.push({
+                property_name: R[s] ?? "",
+                property_value: X[s] ?? "",
+                property_type: O[s] ?? ""
+            });
+        }
+        const ae = e.readParquet(y), L = o.tableFromIPC(ae.intoIPCStream()), _ = L.getChild("qset_id")?.toArray(), ne = L.getChild("qset_name")?.toArray(), J = L.getChild("method_of_measurement")?.toArray(), me = L.getChild("quantity_name")?.toArray(), se = L.getChild("quantity_value")?.toArray(), Y = L.getChild("quantity_type")?.toArray(), k = new Map;
+        for(let s = 0; s < _.length; s++){
+            const U = _[s];
+            k.has(U) || k.set(U, {
+                qset_id: U,
+                qset_name: ne[s] ?? "",
+                method_of_measurement: J[s] || void 0,
+                quantities: []
+            }), k.get(U).quantities.push({
+                quantity_name: me[s] ?? "",
+                quantity_value: se[s] ?? 0,
+                quantity_type: Y[s] ?? ""
+            });
+        }
+        const ie = F.getChild("rel_type")?.toArray(), Z = F.getChild("relating_id")?.toArray(), V = F.getChild("related_id")?.toArray(), h = new Array(Z.length);
+        for(let s = 0; s < Z.length; s++)h[s] = {
+            rel_type: ie[s] ?? "",
+            relating_id: Z[s],
+            related_id: V[s]
+        };
+        const g = new DataView(d.buffer, d.byteOffset, d.byteLength);
+        let p = 0;
+        const M = g.getUint32(p, !0);
+        p += 4;
+        const ce = new Uint8Array(d.buffer, d.byteOffset + p, M);
+        p += M;
+        const ee = g.getUint32(p, !0);
+        p += 4;
+        const pe = new Uint8Array(d.buffer, d.byteOffset + p, ee);
+        p += ee;
+        const te = g.getUint32(p, !0);
+        p += 4;
+        const he = new Uint8Array(d.buffer, d.byteOffset + p, te);
+        p += te;
+        const le = g.getUint32(p, !0);
+        p += 4;
+        const re = new Uint8Array(d.buffer, d.byteOffset + p, le);
+        p += le;
+        const B = g.getUint32(p, !0);
+        p += 4;
+        const ue = new Uint8Array(d.buffer, d.byteOffset + p, B);
+        p += B;
+        const A = g.getUint32(p, !0), W = e.readParquet(ce), j = o.tableFromIPC(W.intoIPCStream()), Ce = j.getChild("entity_id")?.toArray(), Te = j.getChild("parent_id")?.toArray(), Ue = j.getChild("level")?.toArray(), $e = j.getChild("path")?.toArray(), Ee = j.getChild("type_name")?.toArray(), De = j.getChild("name")?.toArray(), ke = j.getChild("elevation")?.toArray(), qe = j.getChild("children_ids"), Se = j.getChild("element_ids"), xe = Ce.length, Pe = new Array(xe);
+        for(let s = 0; s < xe; s++){
+            let U = [], oe = [];
+            if (qe) {
+                const Q = qe.get(s);
+                Q && (U = [
+                    ...Q.toArray()
+                ]);
+            }
+            if (Se) {
+                const Q = Se.get(s);
+                Q && (oe = [
+                    ...Q.toArray()
+                ]);
+            }
+            Pe[s] = {
+                entity_id: Ce[s],
+                parent_id: Te[s] ?? 0,
+                level: Ue[s],
+                path: $e[s] ?? "",
+                type_name: Ee[s] ?? "",
+                name: De[s] || void 0,
+                elevation: ke[s] ?? void 0,
+                children_ids: U,
+                element_ids: oe
+            };
+        }
+        const ye = (s)=>{
+            const U = e.readParquet(s), oe = o.tableFromIPC(U.intoIPCStream()), Q = oe.getChild("element_id")?.toArray(), Ne = oe.getChild("spatial_id")?.toArray(), Ie = new Map;
+            for(let we = 0; we < Q.length; we++)Ie.set(Q[we], Ne[we]);
+            return Ie;
+        }, [Me, Le, ze, Oe] = [
+            ye(pe),
+            ye(he),
+            ye(re),
+            ye(ue)
+        ];
+        return {
+            entities: N,
+            propertySets: H,
+            quantitySets: k,
+            relationships: h,
+            spatialHierarchy: {
+                nodes: Pe,
+                project_id: A,
+                element_to_storey: Me,
+                element_to_building: Le,
+                element_to_site: ze,
+                element_to_space: Oe
+            }
+        };
+    };
+});
+export { We as I, je as d, __tla };

package/dist/assets/wasm-bridge-B0J07fZZ.js

@@ -0,0 +1 @@
+import{I as f,a as d}from"./exporters-C_6J153K.js";import"./bcf-D5-QWGO9.js";import"./zip-B-jFFAGa.js";class z{bridge;initialized=!1;constructor(){this.bridge=new f}async init(){this.initialized||(await this.bridge.init(),this.initialized=!0)}isInitialized(){return this.initialized}async processGeometry(r){this.initialized||await this.init(),performance.now();const i=new d(this.bridge.getApi(),r),n=i.collectMeshes(),s=i.getBuildingRotation();performance.now();let e=0,o=0;for(const c of n)e+=c.positions.length/3,o+=c.indices.length/3;return{meshes:n,totalVertices:e,totalTriangles:o,coordinateInfo:{originShift:{x:0,y:0,z:0},originalBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},shiftedBounds:{min:{x:0,y:0,z:0},max:{x:0,y:0,z:0}},hasLargeCoordinates:!1,buildingRotation:s}}}async processGeometryStreaming(r,i){this.initialized||await this.init();const n=performance.now(),s=new d(this.bridge.getApi(),r);let e=0,o=0,a=0;try{for await(const t of s.collectMeshesStreaming(50)){if(t&&typeof t=="object"&&"type"in t&&t.type==="colorUpdate")continue;const l=t;e+=l.length;for(const m of l)o+=m.positions.length/3,a+=m.indices.length/3;i.onBatch?.({meshes:l,progress:{processed:e,total:e,currentType:"processing"}})}}catch(t){throw i.onError?.(t instanceof Error?t:new Error(String(t))),t}const h=performance.now()-n,g={totalMeshes:e,totalVertices:o,totalTriangles:a,parseTimeMs:h*.3,geometryTimeMs:h*.7};return i.onComplete?.(g),g}getApi(){return this.bridge.getApi()}}export{z as WasmBridge};