opengeometry 2.0.17 → 3.0.0

package/body-registry-MbAD6Hyq.js

@@ -0,0 +1,3159 @@
+import * as THREE from 'three';
+
+function isDetails(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+class OGError extends Error {
+    code;
+    call;
+    details;
+    constructor(code, call, message, details = {}) {
+        super(message);
+        this.name = 'OGError';
+        this.code = code;
+        this.call = call;
+        this.details = isDetails(details) ? details : {};
+    }
+    toJSON() {
+        return { code: this.code, call: this.call, message: this.message, details: this.details };
+    }
+    static fromJSON(value) {
+        return new OGError(value.code, value.call, value.message, value.details);
+    }
+}
+
+let state;
+let creating;
+let epochs = 0;
+function runtime() {
+    if (!state)
+        throw new OGError('NotInitialised', 'OpenGeometry', 'call OpenGeometry.create() first');
+    return state;
+}
+function currentRuntime() {
+    return state;
+}
+function setRuntime(value) {
+    state = value;
+}
+function pendingCreate() {
+    return creating;
+}
+function setPendingCreate(value) {
+    creating = value;
+}
+function nextEpoch() {
+    return ++epochs;
+}
+function bodyKey(handle, generation) {
+    return `${String(handle)}:${String(generation)}`;
+}
+function reindexShape(state, body, previousShapeId) {
+    const shapeId = body.lastInfo.shapeId;
+    if (shapeId === previousShapeId)
+        return;
+    if (previousShapeId) {
+        const previous = state.byShape.get(previousShapeId);
+        previous?.delete(body);
+        if (previous?.size === 0) {
+            state.byShape.delete(previousShapeId);
+            forgetShape(state, previousShapeId);
+        }
+    }
+    if (shapeId)
+        state.byShape.set(shapeId, (state.byShape.get(shapeId) ?? new Set()).add(body));
+}
+function releaseShapeIfEmpty(state, shapeId, revision) {
+    if (state.byShape.get(shapeId)?.size)
+        return;
+    state.byShape.delete(shapeId);
+    forgetShape(state, shapeId);
+    state.records.purge(shapeId);
+    state.provider.drop(shapeId, revision);
+}
+function forgetShape(state, shapeId) {
+    state.lod.shapes.delete(shapeId);
+    state.shapeBuckets.delete(shapeId);
+}
+
+function on(event, handler) {
+    const listeners = runtime().listeners;
+    const group = listeners.get(event) ?? new Set();
+    group.add(handler);
+    listeners.set(event, group);
+    return () => group.delete(handler);
+}
+function emit(event, detail) {
+    for (const handler of currentRuntime()?.listeners.get(event) ?? [])
+        handler(detail);
+}
+
+function parseKernelError(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof value !== 'object' || value === null || !('code' in value) || !('message' in value))
+        return undefined;
+    const { code, message } = value;
+    if (typeof code !== 'string' || typeof message !== 'string' || !code || !message)
+        return undefined;
+    return { code, message, details: 'details' in value ? value.details : undefined };
+}
+
+let wasm;
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogtessellator_free(ptr >>> 0, 1));
+
+const OGWorldGraphFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogworldgraph_free(ptr >>> 0, 1));
+
+class OGWorldGraph {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGWorldGraphFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ogworldgraph_free(ptr, 0);
+    }
+    /**
+     * @param {string} a_json
+     * @param {string} b_json
+     * @param {string} operation
+     * @returns {string}
+     */
+    booleanRegions2D(a_json, b_json, operation) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_booleanRegions2D(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} a_json
+     * @param {string} b_json
+     * @param {string} operation
+     * @returns {string}
+     */
+    booleanCurvedRegions2D(a_json, b_json, operation) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_booleanCurvedRegions2D(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} region_json
+     * @param {number} distance
+     * @returns {string}
+     */
+    insetCurvedRegion2D(region_json, distance) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(region_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_insetCurvedRegion2D(this.__wbg_ptr, ptr0, len0, distance);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {Float64Array} ring
+     * @param {Float64Array} distances
+     * @param {string} holes_json
+     * @returns {string}
+     */
+    offsetRingVariable(ring, distances, holes_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(ring, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(distances, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(holes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_offsetRingVariable(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} region_json
+     * @param {Float64Array} distances
+     * @param {string} hole_distances_json
+     * @returns {string}
+     */
+    offsetCurvedRingVariable(region_json, distances, hole_distances_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(region_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(distances, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(hole_distances_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_offsetCurvedRingVariable(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {Float64Array} path
+     * @param {number} width
+     * @param {boolean} closed
+     * @param {number} miter_limit
+     * @returns {string}
+     */
+    offsetPolylineRegions(path, width, closed, miter_limit) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_offsetPolylineRegions(this.__wbg_ptr, ptr0, len0, width, closed, miter_limit);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {Float64Array} path
+     * @param {number} distance
+     * @param {boolean | null | undefined} closed
+     * @param {boolean} bevel
+     * @param {number} acute_threshold_degrees
+     * @returns {string}
+     */
+    offsetPolyline(path, distance, closed, bevel, acute_threshold_degrees) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_offsetPolyline(this.__wbg_ptr, ptr0, len0, distance, isLikeNone(closed) ? 0xFFFFFF : closed ? 1 : 0, bevel, acute_threshold_degrees);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} primitive_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    createPrimitive(primitive_json, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(primitive_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_createPrimitive(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {Float64Array} points
+     * @param {boolean} closed
+     * @param {string} options_json
+     * @returns {string}
+     */
+    createPolyline(points, closed, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_createPolyline(this.__wbg_ptr, ptr0, len0, closed, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} operation_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    createOperation(operation_json, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(operation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_createOperation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} options_json
+     * @returns {string}
+     */
+    createSystemAssembly(options_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_createSystemAssembly(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} nodes_json
+     * @param {string} options_json
+     * @returns {any}
+     */
+    exportStep(nodes_json, options_json) {
+        const ptr0 = passStringToWasm0(nodes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_exportStep(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    node(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_node(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {number} handle
+     * @param {number} generation
+     * @returns {string}
+     */
+    nodeByHandle(handle, generation) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.ogworldgraph_nodeByHandle(this.__wbg_ptr, handle, generation);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    children(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_children(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    parent(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_parent(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} parent
+     * @param {string} children_json
+     * @param {boolean} keep_world
+     * @returns {string}
+     */
+    addChild(parent, children_json, keep_world) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(parent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(children_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_addChild(this.__wbg_ptr, ptr0, len0, ptr1, len1, keep_world);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} parent
+     * @param {string} child
+     * @param {boolean} keep_world
+     * @returns {string}
+     */
+    removeChild(parent, child, keep_world) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(parent, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(child, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_removeChild(this.__wbg_ptr, ptr0, len0, ptr1, len1, keep_world);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} source
+     * @param {string} options_json
+     * @returns {string}
+     */
+    instance(source, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_instance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} source
+     * @param {string} options_json
+     * @returns {string}
+     */
+    duplicate(source, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_duplicate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    makeUnique(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_makeUnique(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {number}
+     */
+    instanceCount(og_id) {
+        const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_instanceCount(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    dispose(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_dispose(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    exportIfcBody(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_exportIfcBody(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    mark() {
+        const ret = wasm.ogworldgraph_mark(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {number} slot
+     * @returns {string}
+     */
+    rollback(slot) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.ogworldgraph_rollback(this.__wbg_ptr, slot);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} slot
+     */
+    release(slot) {
+        const ret = wasm.ogworldgraph_release(this.__wbg_ptr, slot);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    markStats() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.ogworldgraph_markStats(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {bigint} revision
+     * @returns {any}
+     */
+    changesSince(revision) {
+        const ret = wasm.ogworldgraph_changesSince(this.__wbg_ptr, revision);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} og_id
+     * @param {string} operation_json
+     * @param {string} tools_json
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    operate(og_id, operation_json, tools_json, scope_json) {
+        let deferred6_0;
+        let deferred6_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(operation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(tools_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len3 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_operate(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var ptr5 = ret[0];
+            var len5 = ret[1];
+            if (ret[3]) {
+                ptr5 = 0; len5 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred6_0 = ptr5;
+            deferred6_1 = len5;
+            return getStringFromWasm0(ptr5, len5);
+        } finally {
+            wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {number} thickness
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    shell(og_id, thickness, scope_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_shell(this.__wbg_ptr, ptr0, len0, thickness, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {string} plane_json
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    mirror(og_id, plane_json, scope_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(plane_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_mirror(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {string} transform_json
+     * @returns {string}
+     */
+    transform(og_id, transform_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(transform_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_transform(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    placement(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_placement(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    worldPlacement(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_worldPlacement(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {Float64Array}
+     */
+    worldMatrix(og_id) {
+        const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_worldMatrix(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    bounds(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_bounds(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    localBounds(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_localBounds(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {string} primitive_json
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    rebuildPrimitive(og_id, primitive_json, scope_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(primitive_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_rebuildPrimitive(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {Float64Array} points
+     * @param {boolean} closed
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    rebuildPolyline(og_id, points, closed, scope_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_rebuildPolyline(this.__wbg_ptr, ptr0, len0, ptr1, len1, closed, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {string} operation_json
+     * @param {string} scope_json
+     * @returns {string}
+     */
+    rebuildOperation(og_id, operation_json, scope_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(operation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(scope_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_rebuildOperation(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    revision() {
+        const ret = wasm.ogworldgraph_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    brep(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_brep(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    worldBrep(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_worldBrep(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {number} face_id
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    faceNormalAt(og_id, face_id, point) {
+        const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_faceNormalAt(this.__wbg_ptr, ptr0, len0, face_id, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * @param {string} og_id
+     * @param {Float64Array} point
+     * @returns {string}
+     */
+    classifyPoint(og_id, point) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_classifyPoint(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @param {number | null} [deflection]
+     * @returns {Float64Array}
+     */
+    measure(og_id, deflection) {
+        const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_measure(this.__wbg_ptr, ptr0, len0, !isLikeNone(deflection), isLikeNone(deflection) ? 0 : deflection);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * @param {string} og_id
+     * @returns {any}
+     */
+    validity(og_id) {
+        const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_validity(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    report(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_report(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    edgeKeys(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_edgeKeys(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} og_id
+     * @returns {string}
+     */
+    displayBuckets(og_id) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(og_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ogworldgraph_displayBuckets(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {string} shape_id
+     * @returns {Uint8Array}
+     */
+    snapshot(shape_id) {
+        const ptr0 = passStringToWasm0(shape_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_snapshot(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * @param {string} shape_id
+     * @param {number} bucket
+     * @param {number} max_triangles
+     * @param {number | null} [smooth_angle]
+     * @returns {any}
+     */
+    buffers(shape_id, bucket, max_triangles, smooth_angle) {
+        const ptr0 = passStringToWasm0(shape_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_buffers(this.__wbg_ptr, ptr0, len0, bucket, max_triangles, !isLikeNone(smooth_angle), isLikeNone(smooth_angle) ? 0 : smooth_angle);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} accuracy_json
+     */
+    constructor(accuracy_json) {
+        const ptr0 = passStringToWasm0(accuracy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogworldgraph_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        OGWorldGraphFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+        const ret = arg0.buffer;
+        return ret;
+    };
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_new_405e22f390576ce2 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_780abee5c1739fd7 = function(arg0) {
+        const ret = new Float32Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_78c8a92080461d08 = function(arg0) {
+        const ret = new Float64Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return ret;
+    };
+    imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_e3b321dcfef89fc7 = function(arg0) {
+        const ret = new Uint32Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_93c8e0c1a479fa1a = function(arg0, arg1, arg2) {
+        const ret = new Float64Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_e6b7e69acd4c7354 = function(arg0, arg1, arg2) {
+        const ret = new Float32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_f1dead44d1fc7212 = function(arg0, arg1, arg2) {
+        const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_set_bb8cecf6a62b9f46 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path);
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead');
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('opengeometry_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+function compileKernel(wasmURL) {
+    return WebAssembly.compileStreaming(fetch(wasmURL));
+}
+function initKernel(module) {
+    return __wbg_init({ module_or_path: module });
+}
+function takePanicMessage() {
+    const message = Reflect.get(globalThis, '__opengeometryPanic');
+    Reflect.deleteProperty(globalThis, '__opengeometryPanic');
+    return typeof message === 'string' ? message : undefined;
+}
+
+function kernelCall(call, fn) {
+    try {
+        return fn();
+    }
+    catch (cause) {
+        if (cause instanceof OGError)
+            throw cause;
+        if (cause instanceof WebAssembly.RuntimeError) {
+            throw new OGError('KernelPanic', call, takePanicMessage() ?? cause.message);
+        }
+        const value = typeof cause === 'string' ? parseKernelError(cause) : undefined;
+        if (value)
+            throw new OGError(value.code, call, value.message, value.details);
+        throw new OGError('InvalidGeometry', call, String(cause));
+    }
+}
+function call(name, fn) {
+    const runtime$1 = runtime();
+    if (runtime$1.poisoned)
+        throw new OGError('KernelPanic', name, 'kernel runtime is poisoned');
+    try {
+        return kernelCall(name, fn);
+    }
+    catch (error) {
+        if (error instanceof OGError && error.code === 'KernelPanic') {
+            runtime$1.poisoned = true;
+            emit('fatal', error);
+        }
+        throw error;
+    }
+}
+
+const ACCURACY = { geometric: 1e-8, intersection: 1e-9, tessellation: 0.01, exchange: 1e-6 };
+const MAX_TRIANGLES = 2_000_000;
+const HYSTERESIS_KEEP = [0.75, 4];
+const PIXELS_AT_REST = 0.5;
+const PIXELS_MOVING = 2;
+const EVALUATION_INTERVAL_MS = 100;
+const MOTION_WINDOW_MS = 150;
+
+const BREP_TOPOLOGY = ['vertices', 'edges', 'halfedges', 'loops', 'faces', 'wires', 'shells'];
+const STEP_COUNTS = ['products', 'solids', 'faces', 'edges', 'pcurvelessEdges', 'entities', 'bytes'];
+const REGION_OPERATIONS = ['union', 'intersection', 'subtraction'];
+function encode(value) {
+    return JSON.stringify(value);
+}
+function scope(options) {
+    return encode(options?.instances === 'all' ? 'AllInstances' : 'Node');
+}
+function operationParams(kind, params, call) {
+    if (kind === 'Extrude') {
+        const holes = params['holes'] ?? [];
+        if (!Array.isArray(holes))
+            throw new OGError('InvalidParameter', call, 'holes must be a list of bodies');
+        const holeIds = holes.map((hole) => ogIdOf(hole, call, 'hole'));
+        return { kind, profile: ogIdOf(params['profile'], call, 'profile'), holes: holeIds, distance: params['distance'] };
+    }
+    if (kind === 'Sweep') {
+        const profile = ogIdOf(params['profile'], call, 'profile');
+        return { kind, profile, path: ogIdOf(params['path'], call, 'path'), caps: params['caps'] };
+    }
+    if (kind === 'Revolve')
+        return { ...params, kind, profile: ogIdOf(params['profile'], call, 'profile') };
+    return { kind, ...params };
+}
+function polylinePoints(params, call) {
+    const points = params['points'];
+    if (!Array.isArray(points) || !points.every(isPoint)) {
+        throw new OGError('InvalidParameter', call, 'points must be a list of [x, y, z] points');
+    }
+    return new Float64Array(points.flat());
+}
+function regionsJson(regions, call) {
+    if (!Array.isArray(regions) || !regions.every(isOffsetRegion)) {
+        throw new OGError('InvalidParameter', call, 'regions must be a list of { outer, holes } of { x, y, z } rings');
+    }
+    const ring = (points) => points.map((point) => [point.x, point.y, point.z]);
+    return encode(regions.map((region) => ({ outer: ring(region.outer), holes: region.holes.map(ring) })));
+}
+function regionOperation(value, call) {
+    if (!isRegionOperation(value)) {
+        throw new OGError('InvalidParameter', call, "operation must be 'union', 'intersection' or 'subtraction'");
+    }
+    return value;
+}
+function curvedRegionsJson(regions, call) {
+    if (!Array.isArray(regions))
+        throw new OGError('InvalidParameter', call, 'curved regions must be a list');
+    return encode(regions);
+}
+function numberList(value, call, label) {
+    if (!isNumberList(value))
+        throw new OGError('InvalidParameter', call, `${label} must be a list of numbers`);
+    return value instanceof Float64Array ? value : new Float64Array(value);
+}
+function offsetHolesJson(holes, call) {
+    if (!Array.isArray(holes) || !holes.every(isOffsetHole)) {
+        throw new OGError('InvalidParameter', call, 'holes must be a list of { ring, distances }');
+    }
+    return encode(holes.map((hole) => ({ ring: Array.from(hole.ring), distances: Array.from(hole.distances) })));
+}
+function decodeOffsetPath(text, call) {
+    return decode(text, call, 'offset path', (value) => isFields(value)
+        && isList(value['edges'], isCurvedEdge) && isList(value['bevelled'], isNumber)
+        && typeof value['closed'] === 'boolean');
+}
+function decodeRegions(text, call) {
+    return decode(text, call, 'regions', (value) => isList(value, isOffsetRegion));
+}
+function decodeCurvedRegions(text, call) {
+    return decode(text, call, 'curved regions', (value) => isList(value, isCurvedRegion));
+}
+function decode(text, call, payload, check) {
+    return checked(parsed(text), call, payload, check);
+}
+function decodeNodeInfo(text, call) {
+    return decode(text, call, 'node info', isNodeInfo);
+}
+function decodeCreation(text, call) {
+    return decode(text, call, 'creation', (value) => isFields(value) && isString(value['ogId']));
+}
+function decodePlacement(text, call) {
+    return decode(text, call, 'placement', isPlacement);
+}
+function decodeChildren(text, call) {
+    return decode(text, call, 'children', isStrings);
+}
+function decodeParent(text, call) {
+    return decode(text, call, 'parent', (value) => value === null || isString(value));
+}
+function decodeBounds(text, call) {
+    return decode(text, call, 'bounds', (value) => value === null || isNumbers(value, 6));
+}
+function decodeIfcBody(text, call) {
+    return decode(text, call, 'IFC body', isIfcBody);
+}
+function decodeBrep(text, call) {
+    return decode(text, call, 'brep', isBrep);
+}
+function decodeShapeReport(text, call) {
+    return decode(text, call, 'report', (value) => value === null || isShapeReport(value));
+}
+function decodeMarkStats(text, call) {
+    return decode(text, call, 'mark stats', (value) => isFields(value)
+        && isNumber(value['liveMarks']) && isNumber(value['retainedRevisions']));
+}
+function decodeDisplayBuckets(text, call) {
+    return decode(text, call, 'display buckets', (value) => isFields(value)
+        && Number.isFinite(value['floor']) && Number.isFinite(value['static']));
+}
+function decodeChangeSet(packet, call) {
+    const glue = checked(packet, call, 'change packet', isChangePacket);
+    return { changes: decode(glue.changesJson, call, 'change set', isChangeSet), matrices: glue.matrices };
+}
+function decodeChanges(text, call) {
+    return decode(text, call, 'change set', isChangeSet);
+}
+function decodeStepExport(value, call) {
+    const glue = checked(value, call, 'STEP export', isStepGlue);
+    return { text: glue.text, report: decode(glue.reportJson, call, 'STEP report', isStepReport) };
+}
+function checked(value, call, payload, check) {
+    if (!check(value))
+        throw new OGError('InvalidGeometry', call, `malformed ${payload}`);
+    return value;
+}
+function parsed(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function ogIdOf(value, call, role) {
+    if (isFields(value) && isString(value['ogId']))
+        return value['ogId'];
+    throw new OGError('InvalidParameter', call, `${role} must be a body`);
+}
+function isFields(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNumber(value) {
+    return typeof value === 'number';
+}
+function isStrings(value) {
+    return Array.isArray(value) && value.every(isString);
+}
+function isNumbers(value, length) {
+    return Array.isArray(value) && value.length === length && value.every(isNumber);
+}
+function isPoint(value) {
+    return isNumbers(value, 3);
+}
+function isNodeInfo(value) {
+    return isFields(value) && isString(value['ogId']) && isNumber(value['handle']) && isNumber(value['generation'])
+        && isNullable(value['parent'], isString) && isStrings(value['children']) && isString(value['kind'])
+        && isNullable(value['shapeId'], isString) && isNullable(value['shapeRevision'], isNumber)
+        && isNullable(value['bodyType'], isString);
+}
+function isNullable(value, check) {
+    return value === null || check(value);
+}
+function isPlacement(value) {
+    return isFields(value) && isPoint(value['origin']) && isPoint(value['xDirection']) && isPoint(value['normal'])
+        && isNumber(value['scale']);
+}
+function isBrep(value) {
+    if (!isFields(value) || !isFields(value['topology']))
+        return false;
+    const topology = value['topology'];
+    return isString(value['id']) && isNumber(value['revision']) && isNumber(value['schema_version'])
+        && isFields(value['geometry']) && isFields(value['accuracy']) && isFields(value['quality'])
+        && Array.isArray(value['solids']) && BREP_TOPOLOGY.every((key) => Array.isArray(topology[key]));
+}
+function isShapeReport(value) {
+    return isFields(value) && isFields(value['report']) && isStrings(value['handlers']) && isNumber(value['revision']);
+}
+function isChangePacket(value) {
+    return isFields(value) && isString(value['changesJson']) && value['matrices'] instanceof Float64Array;
+}
+function isChangeSet(value) {
+    const isChanges = (list) => Array.isArray(list)
+        && list.every((item) => isFields(item) && isString(item['ogId']) && isNumber(item['handle'])
+            && isNumber(item['generation']) && isNullable(item['shapeId'], isString)
+            && isNullable(item['shapeRevision'], isNumber));
+    return isFields(value) && isNumber(value['revision'])
+        && isChanges(value['added']) && isChanges(value['changed']) && isChanges(value['removed']);
+}
+function isStepGlue(value) {
+    return isFields(value) && isString(value['text']) && isString(value['reportJson']);
+}
+function isStepReport(value) {
+    return isFields(value) && STEP_COUNTS.every((key) => isNumber(value[key]))
+        && Array.isArray(value['bodies']) && Array.isArray(value['skipped']);
+}
+function isList(value, check) {
+    return Array.isArray(value) && value.every(check);
+}
+function isRegionOperation(value) {
+    return REGION_OPERATIONS.some((operation) => operation === value);
+}
+function hasOnly(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function isOffsetRegion(value) {
+    const isRing = (ring) => isList(ring, (point) => isFields(point) && hasOnly(point, ['x', 'y', 'z'])
+        && isNumber(point['x']) && isNumber(point['y']) && isNumber(point['z']));
+    return isFields(value) && hasOnly(value, ['outer', 'holes']) && isRing(value['outer'])
+        && isList(value['holes'], isRing);
+}
+function isNumberList(value) {
+    return value instanceof Float64Array || isList(value, isNumber);
+}
+function isOffsetHole(value) {
+    return isFields(value) && hasOnly(value, ['ring', 'distances'])
+        && isNumberList(value['ring']) && isNumberList(value['distances']);
+}
+function isCurvedEdge(edge) {
+    return isFields(edge) && (edge['kind'] === 'line' || edge['kind'] === 'arc');
+}
+function isCurvedRegion(value) {
+    const isEdges = (ring) => isList(ring, isCurvedEdge);
+    return isFields(value) && isEdges(value['outer']) && isList(value['holes'], isEdges);
+}
+function isIfcBody(value) {
+    return isFields(value) && value['schema_version'] === 2 && value['length_unit'] === 'metre'
+        && value['up_axis'] === 'Z' && value['coordinate_space'] === 'world'
+        && (value['representation_type'] === 'AdvancedBrep' || value['representation_type'] === 'CSG')
+        && Array.isArray(value['entities']) && Array.isArray(value['solids']) && Array.isArray(value['faces']);
+}
+
+function createHostGroups(release) {
+    return {
+        live: new Set(), of: new WeakMap(), woken: new Set(), pending: new Set(), drawn: false, revision: 0,
+        dropped: new FinalizationRegistry(release),
+    };
+}
+function groupShown(state, group) {
+    return group.pass >= state.pass - 1;
+}
+function groupDisplayed(state, body) {
+    const groups = state.groups.of.get(body);
+    if (!groups)
+        return false;
+    for (const group of groups)
+        if (groupShown(state, group))
+            return true;
+    return false;
+}
+function stampGroup(state, group) {
+    if (!groupShown(state, group))
+        wake(state, group);
+    state.groups.drawn = true;
+    group.pass = state.pass;
+}
+function setMembers(state, group, members) {
+    for (const body of group.members)
+        leave(state, body, group);
+    group.members = new Set(members);
+    for (const body of group.members)
+        join(state, body, group);
+    state.groups.revision++;
+    state.lod.stale = true;
+    if (groupShown(state, group))
+        state.groups.woken.add(group);
+}
+function dropGroup(state, group) {
+    setMembers(state, group, []);
+    group.pass = -Infinity;
+    state.groups.live.delete(group);
+    state.groups.woken.delete(group);
+}
+function dropMember(state, body) {
+    for (const group of state.groups.of.get(body) ?? [])
+        group.members.delete(body);
+    state.groups.of.delete(body);
+    state.groups.pending.delete(body);
+    state.groups.revision++;
+}
+function groupedBodies(state) {
+    const bodies = [];
+    for (const group of state.groups.live) {
+        if (groupShown(state, group))
+            for (const body of group.members)
+                bodies.push(body);
+    }
+    return bodies;
+}
+function groupsKey(state) {
+    let members = 0;
+    for (const group of state.groups.live)
+        if (groupShown(state, group))
+            members += group.members.size + 1;
+    return members;
+}
+function queueGrouped(state, body) {
+    if (state.groups.of.get(body)?.length)
+        state.groups.pending.add(body);
+}
+function shownChanged(state, body) {
+    if (!state.groups.of.get(body)?.length)
+        return;
+    state.groups.pending.add(body);
+    state.groups.revision++;
+    state.lod.stale = true;
+}
+function queueShapes(state, shapeId) {
+    if (shapeId === undefined) {
+        for (const group of state.groups.live)
+            if (groupShown(state, group))
+                state.groups.woken.add(group);
+        return;
+    }
+    for (const body of state.byShape.get(shapeId) ?? [])
+        queueGrouped(state, body);
+}
+function takeWaiting(state) {
+    const groups = state.groups;
+    const waiting = new Set(groups.pending);
+    for (const group of groups.woken)
+        for (const body of group.members)
+            waiting.add(body);
+    groups.pending.clear();
+    groups.woken.clear();
+    groups.drawn = false;
+    return waiting;
+}
+function wake(state, group) {
+    state.lod.stale = true;
+    state.groups.revision++;
+    state.groups.woken.add(group);
+}
+function join(state, body, group) {
+    const groups = state.groups.of.get(body);
+    if (groups)
+        groups.push(group);
+    else
+        state.groups.of.set(body, [group]);
+}
+function leave(state, body, group) {
+    const groups = state.groups.of.get(body) ?? [];
+    const index = groups.indexOf(group);
+    if (index >= 0)
+        groups.splice(index, 1);
+}
+
+function shown(state, body) {
+    return body.visible || state.hostDrawn.get(body) === true;
+}
+function setShown(state, body, value) {
+    const before = shown(state, body);
+    if (state.hostDrawn.has(body))
+        state.hostDrawn.set(body, value);
+    else
+        body.visible = value;
+    if (shown(state, body) !== before)
+        shownChanged(state, body);
+}
+function handToHost(state, body, hostDrawn) {
+    const handed = hostDrawn && !state.hostDrawn.has(body);
+    const before = shown(state, body);
+    shareDrawing(state, body, hostDrawn);
+    if (handed ? shown(state, body) : shown(state, body) !== before)
+        shownChanged(state, body);
+}
+function shareDrawing(state, body, hostDrawn) {
+    const logical = state.hostDrawn.get(body);
+    if (hostDrawn && logical === undefined) {
+        state.hostDrawn.set(body, body.visible);
+        body.visible = false;
+    }
+    else if (!hostDrawn && logical !== undefined) {
+        state.hostDrawn.delete(body);
+        body.visible = logical;
+    }
+}
+
+function isDisplayed(state, body) {
+    if (!shown(state, body))
+        return false;
+    return (state.displayed.get(body) ?? -Infinity) >= state.pass - 1 || groupDisplayed(state, body);
+}
+function displayedBodies(state) {
+    return [...new Set([...state.displayed.keys(), ...groupedBodies(state)])].filter((body) => isDisplayed(state, body));
+}
+function stampedCount(state) {
+    let count = 0;
+    for (const body of state.displayed.keys())
+        if (isDisplayed(state, body))
+            count++;
+    return count;
+}
+function stampDisplayed(state, body) {
+    if (!isDisplayed(state, body))
+        wakeDisplayed(state, body);
+    state.displayed.set(body, state.pass);
+}
+function wakeDisplayed(state, body) {
+    const shapeId = body.lastInfo.shapeId;
+    state.lod.stale = true;
+    if (shapeId)
+        delete state.lod.shapes.get(shapeId)?.overrides;
+}
+
+function worldGraph() {
+    return runtime().graph;
+}
+function node(ogId, label) {
+    return decodeNodeInfo(call(label, () => worldGraph().node(ogId)), label);
+}
+function checkHandle(label, target) {
+    call(label, () => worldGraph().nodeByHandle(target.handle, target.generation));
+}
+function creation(value, label) {
+    return decodeCreation(value, label).ogId;
+}
+function displayBuckets(ogId, label) {
+    return decodeDisplayBuckets(call(label, () => worldGraph().displayBuckets(ogId)), label);
+}
+
+function shapeBuckets(state, body) {
+    const { shapeId, shapeRevision } = body.lastInfo;
+    if (!shapeId || shapeRevision === null)
+        return undefined;
+    let entry = state.shapeBuckets.get(shapeId);
+    if (entry?.revision !== shapeRevision) {
+        entry = readBuckets(body.ogId, shapeRevision);
+        state.shapeBuckets.set(shapeId, entry);
+    }
+    return entry.error === undefined ? entry : undefined;
+}
+function readBuckets(ogId, revision) {
+    try {
+        return { revision, ...displayBuckets(ogId, 'OpenGeometry.flush') };
+    }
+    catch (error) {
+        if (!(error instanceof OGError) || error.code === 'KernelPanic')
+            throw error;
+        return { revision, floor: 0, static: 0, error };
+    }
+}
+function localTarget(world, body) {
+    const scale = worldScale(body);
+    return scale > 0 && Number.isFinite(scale) ? world / scale : undefined;
+}
+function worldScale(body) {
+    return Math.cbrt(Math.abs(body.matrixWorld.determinant()));
+}
+function finestLocal(bodies, valueOf) {
+    let finest;
+    for (const body of bodies) {
+        const value = valueOf(body);
+        const target = value === undefined ? undefined : localTarget(value, body);
+        if (target !== undefined)
+            finest = finest === undefined ? target : Math.min(finest, target);
+    }
+    return finest;
+}
+
+function deflectionBucket(target) {
+    if (!Number.isFinite(target) || target <= 0) {
+        throw new OGError('InvalidParameter', 'deflection', 'invalid display deflection');
+    }
+    return 2 ** Math.floor(Math.log2(target));
+}
+function wantedBucket(target, floor, previous, moving = false) {
+    const value = Math.max(floor, deflectionBucket(target));
+    if (previous === undefined)
+        return value;
+    const [low, high] = HYSTERESIS_KEEP;
+    const kept = moving ? target >= low * previous : target >= low * previous && target <= high * previous;
+    if (kept)
+        return previous;
+    return value;
+}
+
+function displayBounds(state, body, revision) {
+    const cached = state.displayBounds.get(body);
+    if (cached?.revision === revision)
+        return cached.bounds;
+    const label = `${body.bodyType}.getBounds`;
+    const bounds = decodeBounds(call(label, () => state.graph.bounds(body.ogId)), label);
+    state.displayBounds.set(body, { revision, bounds });
+    return bounds;
+}
+
+function worldUnitsPerPixel(camera, bounds, height) {
+    if (camera instanceof THREE.OrthographicCamera)
+        return (camera.top - camera.bottom) / (camera.zoom * height);
+    if (!(camera instanceof THREE.PerspectiveCamera))
+        return 1 / height;
+    const centre = new THREE.Vector3((bounds[0] + bounds[3]) / 2, (bounds[1] + bounds[4]) / 2, (bounds[2] + bounds[5]) / 2);
+    centre.applyMatrix4(camera.matrixWorldInverse);
+    const extent = Math.hypot(bounds[3] - bounds[0], bounds[4] - bounds[1], bounds[5] - bounds[2]) / 2;
+    const depth = Math.max(camera.near, -centre.z - extent);
+    return 2 * depth * Math.tan(THREE.MathUtils.degToRad(camera.getEffectiveFOV()) / 2) / height;
+}
+
+function createLodState(refresh) {
+    return {
+        shapes: new Map(), camera: new Float64Array(33), frames: new WeakMap(), bufferSize: new THREE.Vector2(),
+        initialised: false, lastMotion: -Infinity, lastSchedule: -Infinity, temporaries: [], stale: true, drawn: new Set(),
+        walked: new WeakMap(), refresh,
+    };
+}
+function observe(state, camera, height, now) {
+    const lod = state.lod;
+    const moved = storeChanged(lod.camera, camera.matrixWorld.elements, 0);
+    const projected = storeChanged(lod.camera, camera.projectionMatrix.elements, 16);
+    const resized = lod.camera[32] !== height;
+    lod.camera[32] = height;
+    if (lod.initialised && (moved || projected || resized))
+        motionHint(state, now);
+    lod.initialised = true;
+    lod.lastSeen = { camera, height };
+}
+function storeChanged(target, values, offset) {
+    const same = values.every((value, index) => target[offset + index] === value);
+    if (!same)
+        target.set(values, offset);
+    return !same;
+}
+function motionHint(state, now) {
+    const lod = state.lod;
+    lod.lastMotion = now;
+    lod.stale = true;
+    clearTimeout(lod.settleTimer);
+    lod.settleTimer = setTimeout(() => { fireSettle(state); }, MOTION_WINDOW_MS);
+}
+function fireSettle(state) {
+    delete state.lod.settleTimer;
+    if (currentRuntime() !== state || state.poisoned)
+        return;
+    if (evaluatePass(state, Date.now(), true))
+        state.lod.refresh();
+}
+function settleNow(state) {
+    clearTimeout(state.lod.settleTimer);
+    delete state.lod.settleTimer;
+    evaluatePass(state, Date.now(), true);
+}
+function evaluatePass(state, now, forced) {
+    const lod = state.lod;
+    const seen = lod.lastSeen;
+    if (!seen || state.poisoned || (!forced && now - lod.lastSchedule < EVALUATION_INTERVAL_MS))
+        return false;
+    lod.lastSchedule = now;
+    const moving = !forced && now - lod.lastMotion < MOTION_WINDOW_MS;
+    const revision = call('OpenGeometry.flush', () => state.graph.revision());
+    const groups = [state.groups.revision, groupsKey(state)];
+    const inputs = { revision, flushed: state.revision, moving, displayed: stampedCount(state), groups };
+    if (!forced && !stalePass(lod, inputs))
+        return false;
+    const bodies = displayedBodies(state);
+    lod.stale = false;
+    lod.evaluated = inputs;
+    let changed = false;
+    const pixels = moving ? PIXELS_MOVING : PIXELS_AT_REST;
+    for (const [shapeId, { target, body }] of shapeTargets(state, seen, bodies, inputs.revision, pixels)) {
+        const buckets = shapeBuckets(state, body);
+        if (!buckets)
+            continue;
+        const entry = shapeLod(state, shapeId);
+        const previous = entry.previous;
+        entry.target = target;
+        entry.previous = wantedBucket(target, buckets.floor, previous, moving);
+        changed ||= entry.previous !== previous;
+    }
+    return changed;
+}
+function stalePass(lod, inputs) {
+    const last = lod.evaluated;
+    return lod.stale || !last || last.revision !== inputs.revision || last.flushed !== inputs.flushed
+        || last.moving !== inputs.moving || last.displayed !== inputs.displayed
+        || last.groups.some((value, index) => value !== inputs.groups[index]);
+}
+function shapeTargets(state, seen, bodies, revision, pixels) {
+    const targets = new Map();
+    for (const body of bodies) {
+        const shapeId = body.lastInfo.shapeId;
+        const bounds = shapeId ? displayBounds(state, body, revision) : null;
+        const world = bounds ? worldUnitsPerPixel(seen.camera, bounds, seen.height) * pixels : undefined;
+        const target = world === undefined ? undefined : localTarget(world, body);
+        if (!shapeId || target === undefined || !Number.isFinite(target) || target <= 0)
+            continue;
+        const best = targets.get(shapeId);
+        if (!best || target < best.target)
+            targets.set(shapeId, { target, body });
+    }
+    return targets;
+}
+function wantedKey(state, body) {
+    const { shapeId, shapeRevision: revision } = body.lastInfo;
+    if (!shapeId || revision === null)
+        return undefined;
+    const buckets = shapeBuckets(state, body);
+    if (!buckets)
+        return undefined;
+    const entry = shapeLod(state, shapeId);
+    const forced = entry.forced;
+    if (forced !== undefined) {
+        delete entry.forced;
+        return forced;
+    }
+    if (entry.pinned?.revision === revision)
+        return entry.pinned.bucket;
+    let bucket = chosenBucket(state, body, entry, buckets);
+    while (entry.failed.has(failedKey(revision, bucket)))
+        bucket *= 2;
+    return bucket;
+}
+function chosenBucket(state, body, entry, buckets) {
+    const override = overrideTarget(state, body, entry);
+    if (override !== undefined)
+        return Math.max(buckets.floor, deflectionBucket(override));
+    if (entry.previous !== undefined)
+        return Math.max(buckets.floor, entry.previous);
+    return buckets.static;
+}
+function overrideTarget(state, body, entry) {
+    if (entry.overrides?.pass !== state.pass) {
+        const members = [...(state.byShape.get(entry.shapeId) ?? [])].filter((member) => isDisplayed(state, member));
+        entry.overrides = { pass: state.pass, tiers: tiers(state, members) };
+    }
+    const shape = entry.overrides.tiers;
+    const own = tiers(state, [body]);
+    return finer(shape.temporary, own.temporary) ?? finer(shape.own, own.own) ?? finer(shape.global, own.global);
+}
+function tiers(state, bodies) {
+    return {
+        temporary: finestLocal(bodies, () => state.lod.temporaries.at(-1)?.deflection),
+        own: finestLocal(bodies, (body) => body.appearance.deflection),
+        global: finestLocal(bodies, () => state.displayDeflection),
+    };
+}
+function finer(first, second) {
+    if (first === undefined)
+        return second;
+    return second === undefined ? first : Math.min(first, second);
+}
+function shapeLod(state, shapeId) {
+    let entry = state.lod.shapes.get(shapeId);
+    if (!entry) {
+        entry = { shapeId, failed: new Set() };
+        state.lod.shapes.set(shapeId, entry);
+    }
+    return entry;
+}
+function failedKey(revision, bucket) {
+    return `${String(revision)}#${String(bucket)}`;
+}
+function overrideChanged(state, shapeId) {
+    state.lod.stale = true;
+    queueShapes(state, shapeId);
+    const entries = shapeId === undefined ? [...state.lod.shapes.values()] : [state.lod.shapes.get(shapeId)];
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        clearMarks(entry);
+        delete entry.previous;
+    }
+}
+function pushTemporaryTarget(state, deflection) {
+    const token = { deflection };
+    state.lod.temporaries.push(token);
+    clearAllMarks(state);
+    return token;
+}
+function popTemporaryTarget(state, token) {
+    const temporaries = state.lod.temporaries;
+    temporaries.splice(temporaries.indexOf(token), 1);
+    clearAllMarks(state);
+}
+function clearAllMarks(state) {
+    state.lod.stale = true;
+    queueShapes(state);
+    for (const entry of state.lod.shapes.values())
+        clearMarks(entry);
+}
+function clearMarks(entry) {
+    entry.failed.clear();
+    delete entry.pinned;
+    delete entry.overrides;
+}
+function markFailed(state, shapeId, revision, bucket) {
+    const entry = shapeLod(state, shapeId);
+    const key = failedKey(revision, bucket);
+    if (entry.failed.has(key))
+        return false;
+    entry.failed.add(key);
+    entry.pinned = { revision, bucket: bucket * 2 };
+    state.lod.stale = true;
+    return true;
+}
+function retryBucket(state, shapeId, revision) {
+    const pinned = state.lod.shapes.get(shapeId)?.pinned;
+    return pinned?.revision === revision ? pinned.bucket : undefined;
+}
+function shapePriority(state, shapeId) {
+    return state.lod.shapes.get(shapeId)?.target ?? 0;
+}
+function recordError(state, shapeId, revision, error) {
+    shapeLod(state, shapeId).error = { revision, error };
+}
+function clearError(state, shapeId, revision) {
+    const entry = state.lod.shapes.get(shapeId);
+    if (entry?.error?.revision === revision)
+        delete entry.error;
+}
+function capturedError(state, body) {
+    const { shapeId, shapeRevision } = body.lastInfo;
+    const failure = shapeId ? state.lod.shapes.get(shapeId)?.error : undefined;
+    if (failure?.revision === shapeRevision)
+        return failure.error;
+    const buckets = shapeId ? state.shapeBuckets.get(shapeId) : undefined;
+    return buckets?.revision === shapeRevision ? buckets.error : undefined;
+}
+function forceNextBucket(state, shapeId, bucket) {
+    shapeLod(state, shapeId).forced = bucket;
+    state.lod.stale = true;
+    queueShapes(state, shapeId);
+}
+
+const SCALARS = ['revision', 'bucket', 'achievedDeflection', 'triangles'];
+function validateDisplayBuffers(value) {
+    if (!isDisplayBuffers(value) || !hasConsistentLengths(value)) {
+        throw new OGError('WorkerFailure', 'tessellation', 'invalid display buffer structure');
+    }
+    return value;
+}
+function isDisplayBuffers(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const field = (key) => Reflect.get(value, key);
+    return field('positions') instanceof Float32Array && field('normals') instanceof Float32Array
+        && field('indices') instanceof Uint32Array && field('faceRanges') instanceof Uint32Array
+        && field('outline') instanceof Float32Array && field('edgeIds') instanceof Uint32Array
+        && field('smoothEdges') instanceof Uint8Array
+        && field('origin') instanceof Float64Array && SCALARS.every((key) => typeof field(key) === 'number');
+}
+function hasConsistentLengths(buffers) {
+    return buffers.origin.length === 3 && buffers.positions.length % 3 === 0
+        && buffers.normals.length === buffers.positions.length
+        && buffers.indices.length % 3 === 0 && buffers.indices.length <= 6_000_000
+        && buffers.outline.length % 6 === 0 && buffers.outline.length <= 12_000_000
+        && buffers.edgeIds.length === buffers.outline.length / 6 && buffers.faceRanges.length % 3 === 0;
+}
+
+function recordKey(shapeId, revision, bucket, smoothAngle) {
+    return `${shapeId}@${String(revision)}#${String(Math.log2(bucket))}~${String(smoothAngle)}`;
+}
+class GeometryRecord {
+    shapeId;
+    key;
+    surface;
+    outline;
+    origin;
+    faceRanges;
+    edgeIds;
+    smoothEdges;
+    revision;
+    bucket;
+    triangles;
+    bytes;
+    refs = 0;
+    lastUse = 0;
+    constructor(shapeId, buffers, smoothAngle) {
+        this.shapeId = shapeId;
+        validateDisplayBuffers(buffers);
+        this.key = recordKey(shapeId, buffers.revision, buffers.bucket, smoothAngle);
+        this.revision = buffers.revision;
+        this.bucket = buffers.bucket;
+        this.triangles = buffers.triangles;
+        this.origin = new THREE.Vector3(buffers.origin[0], buffers.origin[1], buffers.origin[2]);
+        this.faceRanges = buffers.faceRanges;
+        this.edgeIds = buffers.edgeIds;
+        this.smoothEdges = buffers.smoothEdges;
+        this.bytes = buffers.positions.byteLength + buffers.normals.byteLength + buffers.indices.byteLength
+            + buffers.faceRanges.byteLength + buffers.outline.byteLength + buffers.edgeIds.byteLength
+            + buffers.smoothEdges.byteLength;
+        this.surface = buffers.indices.length ? new THREE.BufferGeometry() : null;
+        if (this.surface) {
+            this.surface.setAttribute('position', new THREE.BufferAttribute(buffers.positions, 3));
+            this.surface.setAttribute('normal', new THREE.BufferAttribute(buffers.normals, 3));
+            this.surface.setIndex(new THREE.BufferAttribute(buffers.indices, 1));
+            this.surface.computeBoundingBox();
+            this.surface.computeBoundingSphere();
+        }
+        this.outline = new THREE.BufferGeometry();
+        this.outline.setAttribute('position', new THREE.BufferAttribute(buffers.outline, 3));
+        if (buffers.outline.length) {
+            this.outline.computeBoundingBox();
+            this.outline.computeBoundingSphere();
+        }
+    }
+    dispose() {
+        this.surface?.dispose();
+        this.outline.dispose();
+    }
+}
+
+function flush(options = {}) {
+    const state = runtime();
+    const given = options.bodies && liveBodies(state, options.bodies, options.geometry);
+    applyFlush(state);
+    if (options.geometry !== 'sync')
+        return;
+    for (const body of given ?? displayedBodies(state)) {
+        if (given && (!shown(state, body) || !body.lastInfo.shapeId || body.lastInfo.shapeRevision === null))
+            continue;
+        if (given)
+            stampDisplayed(state, body);
+        ensureGeometry(body, true);
+    }
+    if (state.readyShapes.size > 0)
+        applyFlush(state);
+}
+function liveBodies(state, bodies, geometry) {
+    const label = 'OpenGeometry.flush';
+    if (geometry !== 'sync')
+        throw new OGError('InvalidParameter', label, "bodies needs geometry: 'sync'");
+    return checkedBodies(state, bodies, label);
+}
+function checkedBodies(state, bodies, label, skipDisposed = false) {
+    const list = bodies;
+    if (!Array.isArray(list))
+        throw new OGError('InvalidParameter', label, 'bodies must be an array of bodies');
+    const live = [];
+    for (const body of bodies) {
+        const item = body;
+        if (!(item instanceof THREE.Object3D) || !('swapReadyRecord' in item)) {
+            throw new OGError('InvalidParameter', label, 'bodies must hold only Wire, Sheet or Solid bodies');
+        }
+        if (state.bodies.get(bodyKey(body.handle, body.generation)) === body)
+            live.push(body);
+        else if (!skipDisposed)
+            throw new OGError('Disposed', label, `${body.ogId} is disposed`);
+    }
+    return live;
+}
+function flushForDispose() {
+    applyFlush(runtime());
+}
+function notifyBody(body, type) {
+    try {
+        body.dispatchEvent({ type });
+    }
+    catch (error) {
+        emit('error', error);
+    }
+}
+function applyFlush(state) {
+    const revision = call('OpenGeometry.flush', () => state.graph.revision());
+    state.graphMoved = false;
+    if (!state.flushing && (revision !== state.revision || (!state.renderPassActive && state.readyShapes.size > 0))) {
+        state.flushing = true;
+        const moved = [];
+        try {
+            const packet = call('OpenGeometry.flush', () => state.graph.changesSince(state.revision));
+            const { changes, matrices } = decodeChangeSet(packet, 'OpenGeometry.flush');
+            state.revision = revision;
+            moved.push(...applyChanges(state, changes, matrices));
+            for (const body of swapTargets(state, changes))
+                body.swapReadyRecord();
+            purgeChanged(state, changes);
+            state.flushes++;
+        }
+        finally {
+            state.flushing = false;
+        }
+        for (const body of moved)
+            notifyBody(body, 'placementchanged');
+    }
+}
+function swapTargets(state, changes) {
+    const targets = new Set();
+    for (const change of [...changes.added, ...changes.changed]) {
+        const body = state.bodies.get(bodyKey(change.handle, change.generation));
+        if (body)
+            targets.add(body);
+    }
+    for (const shapeId of state.readyShapes)
+        for (const body of state.byShape.get(shapeId) ?? [])
+            targets.add(body);
+    state.readyShapes.clear();
+    return [...targets].filter((body) => isDisplayed(state, body));
+}
+function applyChanges(state, changes, matrices) {
+    const moved = [];
+    let offset = 0;
+    for (const change of [...changes.added, ...changes.changed]) {
+        const body = state.bodies.get(bodyKey(change.handle, change.generation));
+        if (body) {
+            const previous = body.lastInfo.shapeId;
+            body.lastInfo = { ...body.lastInfo, shapeId: change.shapeId, shapeRevision: change.shapeRevision };
+            reindexShape(state, body, previous);
+            const matrix = matrices.subarray(offset, offset + 16);
+            if (body.matrixWorld.elements.some((value, index) => value !== matrix[index]))
+                moved.push(body);
+            body.applyWorldMatrix(matrix);
+            queueGrouped(state, body);
+        }
+        offset += 16;
+    }
+    for (const change of changes.removed)
+        state.bodies.get(bodyKey(change.handle, change.generation))?.hideForDispose();
+    return moved;
+}
+function purgeChanged(state, changes) {
+    const shapes = new Map();
+    for (const { shapeId, shapeRevision } of [...changes.added, ...changes.changed]) {
+        if (shapeId !== null && shapeRevision !== null) {
+            shapes.set(`${shapeId}@${String(shapeRevision)}`, { shapeId, revision: shapeRevision });
+        }
+    }
+    for (const { shapeId, revision } of shapes.values())
+        state.records.purge(shapeId, revision);
+}
+function wanted(body) {
+    return wantedKey(runtime(), body);
+}
+function ensureGeometry(body, sync = false) {
+    const state = runtime();
+    const target = geometryTarget(state, body);
+    if (!target)
+        return;
+    const record = state.records.get(target.shapeId, target.revision, target.bucket, target.smoothAngle);
+    if (record) {
+        body.install(record);
+        return;
+    }
+    if (sync || state.provider.compute) {
+        computeNow(state, target, sync);
+        return;
+    }
+    if (state.pending.has(target.key))
+        return;
+    requestLater(state, target);
+}
+function geometryTarget(state, body) {
+    const { shapeId, shapeRevision: revision } = body.lastInfo;
+    if (!shapeId || revision === null || !shown(state, body))
+        return undefined;
+    const bucket = wantedKey(state, body);
+    if (bucket === undefined)
+        return undefined;
+    const { smoothAngle } = body.appearance;
+    return { body, shapeId, revision, bucket, smoothAngle, key: pendingKey(shapeId, revision, bucket, smoothAngle) };
+}
+function pendingKey(shapeId, revision, bucket, smoothAngle) {
+    return `${shapeId}@${String(revision)}#${String(bucket)}~${String(smoothAngle)}`;
+}
+function computeNow(state, target, sync) {
+    const first = computeFailure(state, target, sync);
+    if (!first)
+        return;
+    const retry = coarserRetry(state, target, first.error);
+    const failure = retry ? computeFailure(state, retry, false) : first;
+    if (failure)
+        reportFailure(state, target, failure.error);
+}
+function computeFailure(state, target, sync) {
+    try {
+        const request = requestFor(state, target);
+        if (sync)
+            state.provider.cancelShape(target.shapeId, request.generation);
+        receive(state, target, computed(state, request));
+        return undefined;
+    }
+    catch (error) {
+        if (fatal(state, error))
+            throw error;
+        return { error };
+    }
+}
+function coarserRetry(state, target, error) {
+    const { shapeId, revision, bucket, smoothAngle } = target;
+    if (!(error instanceof OGError && error.code === 'LimitExceeded') || !markFailed(state, shapeId, revision, bucket)) {
+        return undefined;
+    }
+    emit('warning', { code: 'LimitExceeded', shapeId, revision, bucket, retryBucket: bucket * 2 });
+    return { ...target, bucket: bucket * 2, key: pendingKey(shapeId, revision, bucket * 2, smoothAngle) };
+}
+function reportFailure(state, target, error) {
+    recordError(state, target.shapeId, target.revision, error);
+    emit('error', error);
+}
+function computed(state, request) {
+    if (state.provider.compute)
+        return state.provider.compute(request);
+    return validateDisplayBuffers(call('OpenGeometry.flush', () => state.graph.buffers(request.shapeId, request.bucket, request.maxTriangles, request.smoothAngle)));
+}
+function fatal(state, error) {
+    return state.poisoned && error instanceof OGError && error.code === 'KernelPanic';
+}
+function requestLater(state, target) {
+    let request = requestFor(state, target);
+    const promise = state.provider.request(request).catch(async (error) => {
+        const retry = currentRuntime() === state ? coarserRetry(state, target, error) : undefined;
+        if (!retry)
+            throw error;
+        request = requestFor(state, retry);
+        return state.provider.request(request);
+    }).then((buffers) => {
+        if (currentRuntime() === state && accepted(state, target, buffers, request.generation)) {
+            receive(state, target, buffers);
+        }
+    }).catch((error) => {
+        if (currentRuntime() !== state || fatal(state, error))
+            return;
+        if (!(error instanceof OGError && error.code === 'Cancelled'))
+            reportFailure(state, target, error);
+    }).finally(() => { state.pending.delete(target.key); });
+    state.pending.set(target.key, promise);
+}
+function accepted(state, target, buffers, generation) {
+    const { body, shapeId, revision } = target;
+    if (generation === (state.generations.get(shapeId) ?? 0))
+        return true;
+    if (buffers.bucket === retryBucket(state, shapeId, revision))
+        return true;
+    const wanted = isDisplayed(state, body) ? wantedKey(state, body) : undefined;
+    if (wanted === undefined)
+        return false;
+    const shown = body.record?.shapeId === shapeId && body.record.revision === revision ? body.record.bucket : undefined;
+    return shown === undefined || Math.abs(Math.log2(buffers.bucket / wanted)) < Math.abs(Math.log2(shown / wanted));
+}
+function requestFor(state, target) {
+    const { shapeId, revision, bucket, smoothAngle } = target;
+    const generation = (state.generations.get(shapeId) ?? 0) + 1;
+    state.generations.set(shapeId, generation);
+    const priority = shapePriority(state, shapeId);
+    return { shapeId, revision, bucket, priority, maxTriangles: MAX_TRIANGLES, smoothAngle, generation };
+}
+function receive(state, target, buffers) {
+    const { shapeId, revision } = target;
+    const holders = [...(state.byShape.get(shapeId) ?? [])];
+    const current = holders.filter((body) => body.lastInfo.shapeRevision === revision);
+    if (current.length === 0)
+        return;
+    const record = state.records.put(new GeometryRecord(shapeId, buffers, target.smoothAngle));
+    state.readyShapes.add(shapeId);
+    clearError(state, shapeId, revision);
+    if (state.renderPassActive) {
+        for (const body of current)
+            if (isDisplayed(state, body))
+                body.install(record);
+    }
+    else if (shown(state, target.body) && current.includes(target.body))
+        target.body.install(record);
+    const ogIds = holders.map((body) => body.ogId);
+    emit('geometry', { shapeId, revision, bucket: buffers.bucket, ogIds, stats: { triangles: record.triangles } });
+    if (!state.renderPassActive)
+        flush();
+    state.records.purge(shapeId, revision);
+}
+
+function noteDisplayed(body) {
+    const state = runtime();
+    const starting = beginPass(state);
+    stampDisplayed(state, body);
+    state.lod.walked.set(body, state.pass);
+    state.lod.drawn.delete(body);
+    if (starting || state.graphMoved)
+        flush();
+    ensureGeometry(body);
+}
+function noteDrawn(body) {
+    const state = runtime();
+    if (!shown(state, body) || (state.renderPassActive && state.lod.walked.get(body) === state.pass))
+        return;
+    beginPass(state);
+    stampDisplayed(state, body);
+    state.lod.drawn.add(body);
+}
+function markDisplayed(bodies) {
+    const state = runtime();
+    for (const body of checkedBodies(state, bodies, 'OpenGeometry.markDisplayed'))
+        noteDrawn(body);
+}
+function setHostDrawn(bodies, hostDrawn) {
+    const state = runtime();
+    const label = 'OpenGeometry.setHostDrawn';
+    const flag = hostDrawn;
+    if (typeof flag !== 'boolean')
+        throw new OGError('InvalidParameter', label, 'hostDrawn must be a boolean');
+    for (const body of checkedBodies(state, bodies, label, !hostDrawn))
+        handToHost(state, body, hostDrawn);
+}
+function beginPass(state) {
+    if (state.renderPassActive)
+        return false;
+    state.renderPassActive = true;
+    queueMicrotask(() => { endPass(state); });
+    return true;
+}
+function endPass(state) {
+    if (currentRuntime() !== state)
+        return;
+    const drawn = new Set(state.lod.drawn);
+    state.lod.drawn.clear();
+    try {
+        installDrawn(state, drawn);
+    }
+    finally {
+        state.renderPassActive = false;
+        state.pass++;
+    }
+    if (state.readyShapes.size > 0)
+        flush();
+    if (evaluatePass(state, Date.now(), false))
+        refreshDisplayed(state);
+}
+function installDrawn(state, drawn) {
+    const groups = state.groups;
+    if (drawn.size === 0 && !groups.drawn && groups.pending.size === 0 && groups.woken.size === 0)
+        return;
+    flush();
+    for (const body of takeWaiting(state)) {
+        if (drawn.has(body) || !isDisplayed(state, body))
+            continue;
+        wakeDisplayed(state, body);
+        ensureGeometry(body);
+    }
+    for (const body of drawn)
+        if (isDisplayed(state, body))
+            ensureGeometry(body);
+}
+function refreshDisplayed(state) {
+    for (const body of displayedBodies(state))
+        ensureGeometry(body);
+}
+
+class InlineBackend {
+    graph;
+    activeBackend = 'inline';
+    constructor(graph) {
+        this.graph = graph;
+    }
+    ensureSnapshot() {
+        return Promise.resolve();
+    }
+    compute(value) {
+        const { shapeId, bucket, maxTriangles, smoothAngle } = value;
+        const buffers = call('tessellation', () => this.graph.buffers(shapeId, bucket, maxTriangles, smoothAngle));
+        return validateDisplayBuffers(buffers);
+    }
+    request(value) {
+        return new Promise((resolve) => { resolve(this.compute(value)); });
+    }
+    cancelShape() { }
+    drop() { }
+    dispose() { }
+}
+
+class Deferred {
+    resolve;
+    reject;
+    promise;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        this.promise.catch(() => undefined);
+    }
+}
+
+const SEND_LOG_LIMIT = 1_000;
+class WorkerBackend {
+    graph;
+    module;
+    workerURL;
+    onFailure;
+    activeBackend = 'worker';
+    sendLog = [];
+    live;
+    nextRequest = 1;
+    pending = new Map();
+    snapshots = new Set();
+    latestGenerations = new Map();
+    ready = new Deferred();
+    restarts = 0;
+    failed = false;
+    disposed = false;
+    fallback;
+    constructor(graph, module, workerURL, onFailure) {
+        this.graph = graph;
+        this.module = module;
+        this.workerURL = workerURL;
+        this.onFailure = onFailure;
+        this.fallback = new InlineBackend(graph);
+        this.boot();
+    }
+    get worker() {
+        return this.live;
+    }
+    boot() {
+        try {
+            const worker = new Worker(this.workerURL, { type: 'module' });
+            this.live = worker;
+            worker.onmessage = (event) => { this.receive(event.data); };
+            worker.onerror = () => { this.crash(); };
+            worker.onmessageerror = () => { this.crash(); };
+            worker.postMessage({ kind: 'init', request: 0, module: this.module });
+        }
+        catch {
+            this.crash();
+        }
+    }
+    crash() {
+        if (this.disposed || this.failed)
+            return;
+        this.live?.terminate();
+        this.live = undefined;
+        this.snapshots.clear();
+        if (this.restarts > 0) {
+            this.fail();
+            return;
+        }
+        this.restarts++;
+        this.drain();
+        this.boot();
+    }
+    fail() {
+        this.failed = true;
+        const error = new OGError('WorkerFailure', 'tessellation', 'tessellation worker failed');
+        this.ready.reject(error);
+        this.drain();
+        queueMicrotask(() => { if (!this.disposed)
+            this.onFailure(error); });
+    }
+    drain() {
+        const entries = [...this.pending.entries()];
+        this.pending.clear();
+        for (const [request, { value, resolve, reject }] of entries) {
+            try {
+                resolve(value ? { request, ok: true, buffers: this.fallback.compute(value) } : undefined);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+    }
+    receive(reply) {
+        if ('kind' in reply) {
+            this.snapshots.delete(`${reply.shapeId}@${String(reply.revision)}`);
+            return;
+        }
+        if (reply.request === 0) {
+            if ('ok' in reply)
+                this.ready.resolve();
+            else
+                this.crash();
+            return;
+        }
+        if (reply.request === undefined)
+            return;
+        const pending = this.pending.get(reply.request);
+        if (!pending)
+            return;
+        this.pending.delete(reply.request);
+        if ('error' in reply) {
+            pending.reject(new OGError(reply.error.code, 'tessellation', reply.error.message, reply.error.details));
+            if (reply.error.code === 'KernelPanic')
+                this.crash();
+        }
+        else
+            pending.resolve(reply);
+    }
+    async send(message, transfer = []) {
+        try {
+            await this.ready.promise;
+        }
+        catch {
+            return undefined;
+        }
+        const worker = this.live;
+        if (this.failed || this.disposed || !worker)
+            return undefined;
+        const request = this.nextRequest++;
+        const value = message.kind === 'tessellate' ? message : undefined;
+        if (value)
+            this.recordSend(value);
+        return new Promise((resolve, reject) => {
+            this.pending.set(request, { value, resolve, reject });
+            worker.postMessage({ ...message, request }, transfer);
+        });
+    }
+    recordSend(value) {
+        const { shapeId, bucket, priority, generation } = value;
+        this.sendLog.push({ kind: 'tessellate', shapeId, bucket, priority, generation });
+        if (this.sendLog.length > SEND_LOG_LIMIT)
+            this.sendLog.shift();
+    }
+    async ensureSnapshot(shapeId, revision) {
+        const key = `${shapeId}@${String(revision)}`;
+        if (this.failed || this.snapshots.has(key))
+            return;
+        const bytes = call('tessellation', () => this.graph.snapshot(shapeId));
+        const reply = await this.send({ kind: 'snapshot', shapeId, revision, bytes }, [bytes.buffer]);
+        if (!reply) {
+            if (this.live)
+                await this.ensureSnapshot(shapeId, revision);
+            return;
+        }
+        if (!('ok' in reply))
+            throw new OGError('WorkerFailure', 'snapshot', 'worker rejected snapshot');
+        this.snapshots.add(key);
+    }
+    async request(value) {
+        if (this.failed)
+            return this.fallback.compute(value);
+        this.latestGenerations.set(value.shapeId, value.generation);
+        await Promise.resolve();
+        if (this.latestGenerations.get(value.shapeId) !== value.generation) {
+            throw new OGError('Cancelled', 'tessellation', 'tessellation request superseded');
+        }
+        await this.ensureSnapshot(value.shapeId, value.revision);
+        if (this.latestGenerations.get(value.shapeId) !== value.generation) {
+            throw new OGError('Cancelled', 'tessellation', 'tessellation request superseded');
+        }
+        let reply = await this.send(tessellate(value));
+        if (reply && 'missingSnapshot' in reply) {
+            this.snapshots.delete(`${value.shapeId}@${String(value.revision)}`);
+            await this.ensureSnapshot(value.shapeId, value.revision);
+            reply = await this.send(tessellate(value));
+        }
+        return this.buffersFrom(value, reply);
+    }
+    buffersFrom(value, reply) {
+        if (!reply) {
+            if (this.failed)
+                return this.fallback.compute(value);
+            throw new OGError('WorkerFailure', 'tessellation', 'runtime disposed');
+        }
+        if ('superseded' in reply)
+            throw new OGError('Cancelled', 'tessellation', 'tessellation request superseded');
+        if ('buffers' in reply)
+            return reply.buffers;
+        throw new OGError('WorkerFailure', 'tessellation', 'worker returned no buffers');
+    }
+    cancelShape(shapeId, generation) {
+        this.live?.postMessage({ kind: 'cancel', shapeId, generation });
+    }
+    drop(shapeId, revision) {
+        this.snapshots.delete(`${shapeId}@${String(revision)}`);
+        this.live?.postMessage({ kind: 'drop', shapeId, revision });
+    }
+    dispose() {
+        this.disposed = true;
+        this.live?.terminate();
+        this.live = undefined;
+        const error = new OGError('WorkerFailure', 'tessellation', 'runtime disposed');
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+        this.snapshots.clear();
+        this.ready.reject(error);
+    }
+}
+function tessellate(value) {
+    const { shapeId, revision, bucket, priority, maxTriangles, smoothAngle, generation } = value;
+    return { kind: 'tessellate', shapeId, revision, bucket, priority, maxTriangles, smoothAngle, generation };
+}
+
+function register(body) {
+    const state = runtime();
+    state.bodies.set(bodyKey(body.handle, body.generation), body);
+    state.pickTargets.set(body.surface, body).set(body.outline, body);
+    reindexShape(state, body, null);
+}
+function unregister(body) {
+    const state = runtime();
+    state.displayed.delete(body);
+    dropMember(state, body);
+    state.displayBounds.delete(body);
+    state.lod.stale = true;
+    state.limbo.delete(body);
+    state.bodies.delete(bodyKey(body.handle, body.generation));
+    state.pickTargets.delete(body.surface);
+    state.pickTargets.delete(body.outline);
+    if (body.record)
+        state.records.release(body.record);
+    const info = body.lastInfo;
+    if (!info.shapeId)
+        return;
+    state.byShape.get(info.shapeId)?.delete(body);
+    releaseShapeIfEmpty(state, info.shapeId, info.shapeRevision ?? 0);
+}
+
+export { createHostGroups as $, regionsJson as A, decodeRegions as B, curvedRegionsJson as C, setMembers as D, currentRuntime as E, beginPass as F, stampGroup as G, dropGroup as H, checkedBodies as I, pushTemporaryTarget as J, settleNow as K, refreshDisplayed as L, displayedBodies as M, wantedKey as N, OGError as O, popTemporaryTarget as P, capturedError as Q, observe as R, recordKey as S, compileKernel as T, initKernel as U, setRuntime as V, OGWorldGraph as W, ACCURACY as X, InlineBackend as Y, WorkerBackend as Z, createLodState as _, decodeChildren as a, nextEpoch as a0, emit as a1, pendingCreate as a2, setPendingCreate as a3, on as a4, markDisplayed as a5, setHostDrawn as a6, overrideChanged as a7, motionHint as a8, noteDrawn as a9, register as aa, shown as ab, noteDisplayed as ac, isDisplayed as ad, wanted as ae, notifyBody as af, polylinePoints as ag, operationParams as ah, unregister as ai, flushForDispose as aj, decodeShapeReport as ak, forceNextBucket as al, ensureGeometry as am, wantedBucket as an, decodeParent as b, call as c, decodePlacement as d, encode as e, decodeBounds as f, decodeBrep as g, flush as h, creation as i, decodeStepExport as j, bodyKey as k, checkHandle as l, decodeIfcBody as m, node as n, setShown as o, reindexShape as p, decodeChanges as q, runtime as r, scope as s, decodeMarkStats as t, numberList as u, offsetHolesJson as v, worldGraph as w, decodeCurvedRegions as x, decodeOffsetPath as y, regionOperation as z };
+//# sourceMappingURL=body-registry-MbAD6Hyq.js.map