@ifc-lite/viewer 1.26.0 → 1.28.0

package/dist/assets/server-client-cTCJ-853.js

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