@openbim/ifcx 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 point-grey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,126 @@
-# Temporary Holding Version
+# @openbim/ifcx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Read, write, validate and compose **IFC5 / IFCX** files, and export them as
+GLB, from JavaScript and TypeScript. A WebAssembly build of the
+[`openbim-ifcx`](https://crates.io/crates/openbim-ifcx) Rust crate, from the
+`openbim-ifcx-wasm` crate in [openbimrs/ifcx](https://github.com/openbimrs/ifcx).
+
+Published to npm as `@openbim/ifcx`, a CommonJS build for Node 18 and later.
+Browser bundling works in principle (the crate builds for
+`wasm32-unknown-unknown`) but has no tested recipe yet.
+
+Targets the `ifcx_alpha` draft of buildingSMART's IFC5. IFCX is still a
+moving draft; see the
+[capabilities](https://github.com/openbimrs/ifcx/blob/main/docs/capabilities.md).
+
+## Install
+
+```sh
+npm install @openbim/ifcx
+```
+
+## Example
+
+```js
+const { readFileSync } = require("node:fs");
+const { writeFileSync } = require("node:fs");
+const { IfcxFile, compose, exportGlb } = require("@openbim/ifcx");
+
+const model = readFileSync("model.ifcx"); // a Buffer is a Uint8Array
+const file = IfcxFile.parse(model); // or a string
+console.log(file.header.id, file.nodeCount);
+
+const report = file.validate();
+for (const f of report.failures) {
+  console.log(f.node, f.attribute, f.pointer, f.kind, f.message);
+}
+const text = file.write(); // JSON text, unchanged from the input
+
+// Layers weakest first: the last layer's opinions win.
+const tree = compose([model, readFileSync("overlay.ifcx")]);
+console.log(Object.keys(tree.children)); // the root nodes
+
+// Any glTF viewer opens the result.
+writeFileSync("model.glb", exportGlb([model, readFileSync("overlay.ifcx")]));
+```
+
+## API
+
+| Call | Returns |
+| --- | --- |
+| `IfcxFile.parse(input)` | an `IfcxFile`; `input` is JSON text or UTF-8 bytes |
+| `file.write(pretty?)` | the file as JSON text, lossless |
+| `file.toJSON()` | the file as a plain object (`JSON.stringify(file)` works) |
+| `file.header` | the `header` object |
+| `file.nodeCount` | number of entries in `data` |
+| `file.validate()` | a `ValidationReport` against the file's own `schemas` |
+| `compose(layers, options?)` | the composed tree as a `ComposedNode` |
+| `validate(layers, options?)` | a `ValidationReport` over all layers and resolved imports |
+| `exportGlb(layers, options?)` | the composed model as binary glTF 2.0, a `Uint8Array` |
+
+`layers` is one input or an array of them, weakest first. TypeScript
+declarations ship with the package.
+
+**Lossless round trip.** `write()` keeps key order, fields the draft does
+not define, `null` deletions and every number exactly as read. A plain
+object from `toJSON()` cannot promise that: JavaScript lists integer-like
+keys first and rounds integers beyond 2^53. Keep the `IfcxFile` and call
+`write()` to save a file.
+
+**Composed tree.** `compose` returns the artificial root (path `""`) over
+every root node. Each node is `{ path, attributes, children }`, the shape of
+upstream's `PostCompositionNode`, with `children` keyed by child name. Nodes
+shared through inheritance appear once per place they are used.
+
+**Imports.** Without `options.imports`, imports are not resolved: the layers'
+schemas and data are concatenated in order, as upstream's `Federate` does.
+With `options.imports` (an object or a `Map` from the exact import `uri` to
+a file), the layers become the imports of a synthetic main layer, as
+upstream's `ifcx compose` command builds it, and every import must be
+supplied. `integrity` values are checked against the supplied bytes. In
+upstream order an import overrides the layer that imports it, and a later
+layer overrides both. Nothing is fetched from the network or the
+filesystem.
+
+**GLB export.** `exportGlb` writes the render scene of the composed tree:
+transformed, instanced meshes, lines and points with their materials, one
+glTF node per instance named by its IFCX path. The root node turns IFCX's
+Z-up into glTF's Y-up (`yUp: false` keeps Z-up) and carries the scene
+origin, so georeferenced models keep their coordinates
+(`originOnRoot: false` centres the model on the glTF origin instead).
+Geometry values that do not decode are left out. `options.imports` works
+as for `compose`.
+
+**Validation report.** `{ valid, failures }`, each failure
+`{ node, attribute, pointer, kind, message }`: the node path, the attribute
+id, an RFC 6901 pointer into the value (`""` for the value itself), a stable
+`kind` such as `missing-schema`, `type-mismatch`, `not-an-integer`,
+`not-an-option`, `missing-key`, `too-few-elements` or `too-many-elements`,
+and a human message.
+
+## Errors
+
+Every failure throws an `Error` with `name === "IfcxError"` and a stable
+`code`:
+
+| `code` | Meaning |
+| --- | --- |
+| `read` | not an IFCX file: invalid JSON or the wrong shape; the message gives line and column |
+| `write` | the file could not be written |
+| `layer` | imports could not be resolved: a missing file, an import cycle, an `integrity` mismatch |
+| `compose` | a reference cycle, or a reference to a node no layer defines |
+| `invalid-argument` | an argument of the wrong type, or no layers |
+| `glb` | the scene could not be written as GLB (over 4 GiB) |
+
+A code is never renamed or reused.
+
+## Building
+
+```sh
+cargo install wasm-bindgen-cli --version 0.2.128 --locked
+crates/openbim-ifcx-wasm/scripts/build-node-pkg.sh   # builds pkg/ and runs the Node suite
+```
+
+## License
+
+MIT, like the rest of `openbimrs/ifcx`.

package/openbim_ifcx_wasm.d.ts

@@ -0,0 +1,137 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** An IFCX file as JSON text or as its UTF-8 bytes. */
+export type IfcxInput = string | Uint8Array;
+
+/** Options for `compose` and `validate`. */
+export interface LayerOptions {
+    /**
+     * Files that imports name, keyed by the exact import `uri`. When given
+     * (even empty), imports are resolved as upstream does and every import
+     * must be here; without it, imports are not resolved.
+     */
+    imports?: Record<string, IfcxInput> | Map<string, IfcxInput>;
+}
+
+/** One node of a composed tree. The root has path `""`. */
+export interface ComposedNode {
+    path: string;
+    attributes: Record<string, unknown>;
+    children: Record<string, ComposedNode>;
+}
+
+/** The `kind` of a validation failure. */
+export type ValidationFailureKind =
+| "missing-schema"
+| "unknown-inherited-schema"
+| "inheritance-cycle"
+| "type-mismatch"
+| "not-an-integer"
+| "not-an-option"
+| "missing-key"
+| "too-few-elements"
+| "too-many-elements"
+| "missing-restrictions"
+| "unknown-data-type"
+| "other";
+
+/** One attribute value that does not match its schema. */
+export interface ValidationFailure {
+    /** Path of the node carrying the attribute. */
+    node: string;
+    /** Attribute id, which is also the schema id. */
+    attribute: string;
+    /** RFC 6901 JSON pointer into the value; `""` for the value itself. */
+    pointer: string;
+    kind: ValidationFailureKind;
+    message: string;
+}
+
+export interface ValidationReport {
+    valid: boolean;
+    failures: ValidationFailure[];
+}
+
+/**
+ * Compose layers, weakest first, into a tree of plain objects: the
+ * artificial root (path `""`) over every root node.
+ */
+export function compose(layers: IfcxInput | IfcxInput[], options?: LayerOptions): ComposedNode;
+
+/**
+ * Check the attributes of the layers, weakest first, against the schemas of
+ * every layer (and of resolved imports), after merging nodes that share a
+ * path.
+ */
+export function validate(layers: IfcxInput | IfcxInput[], options?: LayerOptions): ValidationReport;
+
+/** Options for `exportGlb`. */
+export interface GlbOptions extends LayerOptions {
+    /** Rotate IFCX's Z-up axes to glTF's Y-up. Default `true`. */
+    yUp?: boolean;
+    /**
+     * Keep the model's coordinates by putting the scene origin on the root
+     * node. With `false` the model sits around the glTF origin, which is then
+     * only recorded in the root's `extras.ifcxOrigin`. Default `true`.
+     */
+    originOnRoot?: boolean;
+}
+
+/**
+ * Compose layers, weakest first, and write their render scene as a binary
+ * glTF 2.0 (`.glb`) file: transformed, instanced meshes, lines and points
+ * with their materials, one glTF node per instance named by its IFCX path.
+ */
+export function exportGlb(layers: IfcxInput | IfcxInput[], options?: GlbOptions): Uint8Array;
+
+/** The `code` of an `IfcxError`. */
+export type IfcxErrorCode =
+| "read"
+| "write"
+| "layer"
+| "compose"
+| "invalid-argument"
+| "glb";
+
+
+
+/**
+ * One IFCX file. Writing it back is lossless: key order, unknown fields,
+ * `null` deletions and every number stay as read.
+ *
+ * A newtype because `wasm_bindgen` can only export a type defined in this
+ * crate; all state and behaviour are the core's.
+ */
+export class IfcxFile {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Read an IFCX file from its JSON text or UTF-8 bytes.
+     */
+    static parse(input: IfcxInput): IfcxFile;
+    /**
+     * The file as a plain object, so `JSON.stringify(file)` works. Unlike
+     * `write`, a plain object may reorder integer-like keys and round
+     * integers beyond 2^53.
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Check every attribute against this file's own `schemas`. Imports are
+     * not resolved; use the `validate` function to include them.
+     */
+    validate(): ValidationReport;
+    /**
+     * The file as JSON text; `pretty` indents it by two spaces.
+     */
+    write(pretty?: boolean | null): string;
+    /**
+     * The `header` object.
+     */
+    readonly header: Record<string, unknown>;
+    /**
+     * Number of entries in `data`; several may share a path.
+     */
+    readonly nodeCount: number;
+}

package/openbim_ifcx_wasm.js

@@ -0,0 +1,489 @@
+/* @ts-self-types="./openbim_ifcx_wasm.d.ts" */
+
+/**
+ * One IFCX file. Writing it back is lossless: key order, unknown fields,
+ * `null` deletions and every number stay as read.
+ *
+ * A newtype because `wasm_bindgen` can only export a type defined in this
+ * crate; all state and behaviour are the core's.
+ */
+class IfcxFile {
+    static __wrap(ptr) {
+        const obj = Object.create(IfcxFile.prototype);
+        obj.__wbg_ptr = ptr;
+        IfcxFileFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IfcxFileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ifcxfile_free(ptr, 0);
+    }
+    /**
+     * The `header` object.
+     * @returns {Record<string, unknown>}
+     */
+    get header() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_header(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Number of entries in `data`; several may share a path.
+     * @returns {number}
+     */
+    get nodeCount() {
+        const ret = wasm.ifcxfile_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Read an IFCX file from its JSON text or UTF-8 bytes.
+     * @param {IfcxInput} input
+     * @returns {IfcxFile}
+     */
+    static parse(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_parse(retptr, addBorrowedObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return IfcxFile.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * The file as a plain object, so `JSON.stringify(file)` works. Unlike
+     * `write`, a plain object may reorder integer-like keys and round
+     * integers beyond 2^53.
+     * @returns {Record<string, unknown>}
+     */
+    toJSON() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_toJSON(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check every attribute against this file's own `schemas`. Imports are
+     * not resolved; use the `validate` function to include them.
+     * @returns {ValidationReport}
+     */
+    validate() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_validate(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The file as JSON text; `pretty` indents it by two spaces.
+     * @param {boolean | null} [pretty]
+     * @returns {string}
+     */
+    write(pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcxfile_write(retptr, this.__wbg_ptr, isLikeNone(pretty) ? 0xFFFFFF : pretty ? 1 : 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) IfcxFile.prototype[Symbol.dispose] = IfcxFile.prototype.free;
+exports.IfcxFile = IfcxFile;
+
+/**
+ * Compose layers, weakest first, into a tree of plain objects: the
+ * artificial root (path `""`) over every root node. Declared for
+ * TypeScript in `TYPES`, where `options` can be optional.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+function compose(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.compose(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+exports.compose = compose;
+
+/**
+ * Compose layers, weakest first, and write their render scene as GLB
+ * bytes. Declared for TypeScript in `TYPES`.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {Uint8Array}
+ */
+function exportGlb(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.exportGlb(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+exports.exportGlb = exportGlb;
+
+/**
+ * Check the attributes of the layers, weakest first, against the schemas
+ * of every layer (and of resolved imports), after merging nodes that share
+ * a path. Declared for TypeScript in `TYPES`.
+ * @param {any} layers
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+function validate(layers, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validate(retptr, addBorrowedObject(layers), isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        heap[stack_pointer++] = undefined;
+    }
+}
+exports.validate = validate;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_boolean_get_7a12af2b3f899c5a: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_is_null_5160b3e381865372: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_edb6b15aa3afe12e: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_entries_20b9608d57d8ddd6: function(arg0) {
+            const ret = getObject(arg0).entries();
+            return addHeapObject(ret);
+        },
+        __wbg_entries_972a87586902cf87: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_from_a39669ce566077da: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_get_989d0a1309644f2b: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_b1f0ab13c737f856: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_unchecked_363572bdd397d473: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_instanceof_Map_1ff6a2b54c899f0d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_598adc0fef426aa8: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_5674713bb7b79043: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_length_31bdaf014f5fbde2: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_4e1adc0d42e23620: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_new_a32a1ab6c6655abe: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_parse_6937a9050adfb0e1: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_set_a377297433dfea63: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_name_6e2a5da46a9ae1e7: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./openbim_ifcx_wasm_bg.js": import0,
+    };
+}
+
+const IfcxFileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ifcxfile_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+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 getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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 = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let stack_pointer = 1024;
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/openbim_ifcx_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;

package/openbim_ifcx_wasm_bg.wasm.d.ts

@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_ifcxfile_free: (a: number, b: number) => void;
+export const compose: (a: number, b: number, c: number) => void;
+export const exportGlb: (a: number, b: number, c: number) => void;
+export const ifcxfile_header: (a: number, b: number) => void;
+export const ifcxfile_nodeCount: (a: number) => number;
+export const ifcxfile_parse: (a: number, b: number) => void;
+export const ifcxfile_toJSON: (a: number, b: number) => void;
+export const ifcxfile_validate: (a: number, b: number) => void;
+export const ifcxfile_write: (a: number, b: number, c: number) => void;
+export const validate: (a: number, b: number, c: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@openbim/ifcx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Read, write, validate and compose IFC5 / IFCX files, and export GLB, from JavaScript (WebAssembly build of openbim-ifcx).",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openbimrs/ifcx.git",
+    "directory": "crates/openbim-ifcx-wasm"
+  },
+  "type": "commonjs",
+  "main": "openbim_ifcx_wasm.js",
+  "types": "openbim_ifcx_wasm.d.ts",
+  "files": [
+    "openbim_ifcx_wasm.js",
+    "openbim_ifcx_wasm.d.ts",
+    "openbim_ifcx_wasm_bg.wasm",
+    "openbim_ifcx_wasm_bg.wasm.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["ifcx", "ifc5", "ifc", "bim", "openbim", "gltf", "wasm"]
+}