@ifc-lite/viewer 1.29.0 → 1.30.0

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

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