@bldrs-ai/conway 1.443.1325 → 1.445.1339

package/compiled/src/ifc/ifc_geometry_extraction.js

@@ -1,4 +1,5 @@
 import { BlendMode, } from "../../dependencies/conway-geom/index.js";
+import { Uint32Sink } from "../step/parsing/uint32_sink.js";
 import { exponentToRoughness } from "../core/canonical_material.js";
 import { CanonicalMeshType } from "../core/canonical_mesh.js";
 import { yieldToEventLoop } from "../core/progress.js";
@@ -108,6 +109,12 @@ export function extractColorOrFactorMultiply(from, surfaceColor, alpha = 1) {
  * Handles Geometry data extraction from a populated IfcStepModel
  * Can export to OBJ, GLTF (Draco), GLB (Draco)
  */
+/**
+ * Starting capacities for the reused polygonal-faceset sinks: enough that a
+ * typical faceset never reallocates, while still growing for outliers.
+ */
+const POLYGONAL_INDEX_SINK_CAPACITY = 65536;
+const POLYGONAL_FACE_SINK_CAPACITY = 16384;
 export class IfcGeometryExtraction {
     constructor(conwayModel, model, limitCSGDepth = true, csgDepthLimit = 20, lowMemoryMode = false) {
         this.conwayModel = conwayModel;
@@ -115,6 +122,13 @@ export class IfcGeometryExtraction {
         this.limitCSGDepth = limitCSGDepth;
         this.csgDepthLimit = csgDepthLimit;
         this.lowMemoryMode = lowMemoryMode;
+        /* Reused across polygonal-faceset extractions; see extractPolygonalFaceSet. */
+        this.polygonalIndexSink_ = new Uint32Sink(POLYGONAL_INDEX_SINK_CAPACITY);
+        this.polygonalStartIndexSink_ = new Uint32Sink(POLYGONAL_FACE_SINK_CAPACITY);
+        this.polygonalFaceOffsetSink_ = new Uint32Sink(POLYGONAL_FACE_SINK_CAPACITY);
+        this.polygonalStartOffsetSink_ = new Uint32Sink(POLYGONAL_FACE_SINK_CAPACITY);
+        /* Guards the sinks against a re-entrant faceset extraction. */
+        this.polygonalSinksInUse_ = false;
         this.TWO_DIMENSIONS = 2;
         this.THREE_DIMENSIONS = 3;
         this.circleSegments = 12;
@@ -525,11 +539,30 @@ export class IfcGeometryExtraction {
      */
     extractPolygonalFaceSet(entity, temporary = false, isRelVoid = false) {
         const result = ExtractResult.COMPLETE;
-        // Temporary storage for indices and start indices
-        const allIndices = [];
-        const allStartIndices = [];
-        const polygonalFaceBufferOffsets = [];
-        const startIndicesBufferOffsets = [];
+        // Reusable typed sinks. A tessellated model can carry millions of
+        // IfcIndexedPolygonalFace records, and the boxed `Array< number >`
+        // this loop used to build per face — which the generated CoordIndex
+        // getter also cached on the face, keeping it alive — dominated both
+        // GC time and retained heap during extraction. Indices are parsed
+        // straight from the STEP buffer into these instead, reused across
+        // facesets.
+        // The sinks are extractor-scoped, so a nested faceset extraction
+        // reached from inside this one would silently clobber them. Nothing
+        // in the window between reset and the wasm copies below recurses
+        // today (the face loop only parses), so this guards the invariant
+        // rather than a live bug — fail loudly if that ever changes.
+        if (this.polygonalSinksInUse_) {
+            throw new Error("extractPolygonalFaceSet re-entered: the shared index sinks are already in use");
+        }
+        this.polygonalSinksInUse_ = true;
+        const allIndices = this.polygonalIndexSink_;
+        const allStartIndices = this.polygonalStartIndexSink_;
+        const polygonalFaceBufferOffsets = this.polygonalFaceOffsetSink_;
+        const startIndicesBufferOffsets = this.polygonalStartOffsetSink_;
+        allIndices.reset();
+        allStartIndices.reset();
+        polygonalFaceBufferOffsets.reset();
+        startIndicesBufferOffsets.reset();
         let indicesPerFace = -1;
         // Prepare indices and start indices for all faces
         entity.Faces.forEach((polygonalFace) => {
@@ -539,35 +572,43 @@ export class IfcGeometryExtraction {
             startIndicesBufferOffsets.push(allStartIndices.length);
             let coordIndex = 0;
             if (polygonalFace instanceof IfcIndexedPolygonalFaceWithVoids) {
+                // Voided faces are rare; keep the straightforward getter path.
                 indicesPerFace = polygonalFace.CoordIndex.length;
                 allStartIndices.push(0);
                 coordIndex += indicesPerFace;
-                allIndices.push(...polygonalFace.CoordIndex);
+                for (const index of polygonalFace.CoordIndex) {
+                    allIndices.push(index);
+                }
                 polygonalFace.InnerCoordIndices.forEach((innerIndices) => {
                     allStartIndices.push(coordIndex);
-                    allIndices.push(...innerIndices);
+                    for (const index of innerIndices) {
+                        allIndices.push(index);
+                    }
                     coordIndex += innerIndices.length;
                 });
             }
             else {
-                indicesPerFace = polygonalFace.CoordIndex.length;
+                // CoordIndex is vtable offset 0 on IfcIndexedPolygonalFace (see
+                // its generated getter) — parsed in place, never allocated or cached.
+                indicesPerFace = polygonalFace.extractIntegerArrayInto(0, 0, 3, allIndices);
                 allStartIndices.push(0);
-                allIndices.push(...polygonalFace.CoordIndex);
             }
         });
         // Add the final entry
         polygonalFaceBufferOffsets.push(allIndices.length);
         startIndicesBufferOffsets.push(allStartIndices.length);
-        // Convert to typed arrays for transfer to WebAssembly
-        const indicesArray = new Uint32Array(allIndices);
+        // Views over exactly the appended elements — no intermediate copy.
+        const indicesArray = allIndices.view;
         const indicesArrayPtr = this.arrayToWasmHeap(indicesArray);
-        const startIndicesArray = new Uint32Array(allStartIndices);
+        const startIndicesArray = allStartIndices.view;
         const startIndicesArrayPtr = this.arrayToWasmHeap(startIndicesArray);
-        const polygonalFaceBufferOffsetsArray = new Uint32Array(polygonalFaceBufferOffsets);
+        const polygonalFaceBufferOffsetsArray = polygonalFaceBufferOffsets.view;
         const polygonalFaceBufferOffsetsArrayPtr = this.arrayToWasmHeap(polygonalFaceBufferOffsetsArray);
-        const startIndicesBufferOffsetsArray = new Uint32Array(startIndicesBufferOffsets);
+        const startIndicesBufferOffsetsArray = startIndicesBufferOffsets.view;
         const startIndicesBufferOffsetsArrayPtr = this.arrayToWasmHeap(startIndicesBufferOffsetsArray);
-        const polygonalFaceVector = this.wasmModule.buildIndexedPolygonalFaceVector(indicesArrayPtr, indicesArray.length, startIndicesArrayPtr, polygonalFaceBufferOffsetsArrayPtr, polygonalFaceBufferOffsets.length, startIndicesBufferOffsetsArrayPtr, startIndicesBufferOffsets.length);
+        const polygonalFaceVector = this.wasmModule.buildIndexedPolygonalFaceVector(indicesArrayPtr, indicesArray.length, startIndicesArrayPtr, polygonalFaceBufferOffsetsArrayPtr, polygonalFaceBufferOffsetsArray.length, startIndicesBufferOffsetsArrayPtr, startIndicesBufferOffsetsArray.length);
+        // Sink contents are now copied into wasm; the sinks are free again.
+        this.polygonalSinksInUse_ = false;
         const pointsParseBuffer = this.conwayModel.nativeParseBuffer();
         if (!entity.Coordinates.extractParseBuffer(0, 0, 0, pointsParseBuffer, this.wasmModule, true)) {
             pointsParseBuffer.resize(0);
@@ -614,7 +655,10 @@ export class IfcGeometryExtraction {
         const arrayPtr = this.wasmModule._malloc(numBytes);
         // Create a new Uint8Array view on the Wasm memory buffer, then set the array to it
         const arrayWasm = new Uint8Array(this.wasmModule.HEAPU8.buffer, arrayPtr, numBytes);
-        arrayWasm.set(new Uint8Array(array.buffer));
+        // Honour the view's own window: subarray() results share their parent's
+        // backing buffer, so copying `array.buffer` wholesale would read the
+        // wrong bytes (and the wrong length) for a view.
+        arrayWasm.set(new Uint8Array(array.buffer, array.byteOffset, numBytes));
         return arrayPtr;
     }
     /**

package/compiled/src/step/parsing/decode_utf8.d.ts

@@ -27,6 +27,21 @@
  * @return The decoded string.
  */
 export declare function decodeUtf8(view: Uint8Array): string;
+/**
+ * Decode the raw byte run of a STEP string literal.
+ *
+ * ISO 10303-21 says raw (non-\X\-escaped) bytes are ISO 8859-1, but modern
+ * exporters routinely write UTF-8 (and some, like Onshape's ST-Developer,
+ * write outright invalid sequences). The lenient default decoder mapped every
+ * non-UTF-8 byte to U+FFFD, so a spec-conformant latin-1 'Küche' surfaced as
+ * 'K�che' in product names and titles. Decode as strict UTF-8 first (the
+ * common modern case, and unambiguous when it validates), and fall back to
+ * exact ISO 8859-1 (byte = code point, which cannot fail) when it doesn't.
+ *
+ * @param view The bytes of the string literal's raw run.
+ * @return The decoded string.
+ */
+export declare function decodeStepString(view: Uint8Array): string;
 /**
  * Install a global, idempotent `TextDecoder.prototype.decode` shim that copies a
  * view out of a resizable/growable buffer before decoding. This covers decodes

package/compiled/src/step/parsing/decode_utf8.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode_utf8.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/decode_utf8.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA+BH;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEnD;AAID;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,IAAI,IAAI,CAqBtD"}
+{"version":3,"file":"decode_utf8.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/decode_utf8.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA+BH;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEnD;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAczD;AAID;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,IAAI,IAAI,CAqBtD"}

package/compiled/src/step/parsing/decode_utf8.js

@@ -54,6 +54,34 @@ function copyOutOfResizable(view) {
 export function decodeUtf8(view) {
     return decoder.decode(decodeNeedsCopy(view.buffer) ? view.slice() : view);
 }
+const strictUtf8Decoder = new TextDecoder('utf-8', { fatal: true });
+/**
+ * Decode the raw byte run of a STEP string literal.
+ *
+ * ISO 10303-21 says raw (non-\X\-escaped) bytes are ISO 8859-1, but modern
+ * exporters routinely write UTF-8 (and some, like Onshape's ST-Developer,
+ * write outright invalid sequences). The lenient default decoder mapped every
+ * non-UTF-8 byte to U+FFFD, so a spec-conformant latin-1 'Küche' surfaced as
+ * 'K�che' in product names and titles. Decode as strict UTF-8 first (the
+ * common modern case, and unambiguous when it validates), and fall back to
+ * exact ISO 8859-1 (byte = code point, which cannot fail) when it doesn't.
+ *
+ * @param view The bytes of the string literal's raw run.
+ * @return The decoded string.
+ */
+export function decodeStepString(view) {
+    const bytes = decodeNeedsCopy(view.buffer) ? view.slice() : view;
+    try {
+        return strictUtf8Decoder.decode(bytes);
+    }
+    catch {
+        let result = '';
+        for (let where = 0; where < bytes.length; ++where) {
+            result += String.fromCharCode(bytes[where]);
+        }
+        return result;
+    }
+}
 let shimInstalled = false;
 /**
  * Install a global, idempotent `TextDecoder.prototype.decode` shim that copies a

package/compiled/src/step/parsing/step_string_parser.js

@@ -1,6 +1,6 @@
 import ParsingConstants from "../../parsing/parsing_constants.js";
 import ParsingDfa16Table from "../../parsing/parsing_dfa_16table.js";
-import { decodeUtf8, installResizableTextDecoderShim } from "./decode_utf8.js";
+import { decodeStepString, installResizableTextDecoderShim } from "./decode_utf8.js";
 // Emscripten 6's browser wasm heap is a resizable ArrayBuffer, on which strict
 // browsers' TextDecoder.decode() throws — including the glue's own UTF8ToString
 // during geometry extraction. Install the global copy-first shim as the STEP
@@ -76,7 +76,7 @@ class StepStringParser extends ParsingDfa16Table {
                             if (nextCursor < endCursor && input[nextCursor] === QUOTE) {
                                 result ??= "";
                                 if (cursor > reificationIndex) {
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor - 1));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor - 1));
                                 }
                                 result += "'";
                                 cursor = nextCursor + 1;
@@ -84,7 +84,7 @@ class StepStringParser extends ParsingDfa16Table {
                             }
                             else {
                                 result ??= "";
-                                result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                result += decodeStepString(input.subarray(reificationIndex, cursor));
                                 return result;
                             }
                         }
@@ -111,7 +111,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     const nextChar2 = input[nextCursor2];
                                     if (nextChar2 !== BSLASH) {
                                         result ??= "";
-                                        result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                        result += decodeStepString(input.subarray(reificationIndex, cursor));
                                         cursor = nextCursor2 + 1;
                                         break;
                                     }
@@ -124,7 +124,7 @@ class StepStringParser extends ParsingDfa16Table {
                                         return result;
                                     }
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     codePage = nextChar3 - A;
                                     cursor = nextCursor3 + 1;
                                     reificationIndex = cursor;
@@ -138,7 +138,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     const nextChar2 = input[nextCursor2];
                                     if (nextChar2 !== BSLASH) {
                                         result ??= "";
-                                        result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                        result += decodeStepString(input.subarray(reificationIndex, cursor));
                                         cursor = nextCursor2 + 1;
                                         break;
                                     }
@@ -148,7 +148,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     }
                                     const nextChar3 = input[nextCursor3];
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     /* eslint-disable no-magic-numbers */
                                     if (nextChar3 < 127) {
                                         result += String.fromCharCode(nextChar3);
@@ -171,7 +171,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     }
                                     const nextChar2 = input[nextCursor2];
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     const hexParserTil0 = (count) => {
                                         if (nextCursor2 + 1 >= endCursor || input[nextCursor2 + 1] !== BSLASH) {
                                             return false;

package/compiled/src/step/parsing/uint32_sink.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Growable Uint32Array append sink.
+ *
+ * Exists so hot extraction loops can parse integer list fields straight
+ * out of the STEP buffer into one reusable typed array, instead of
+ * allocating (and caching) a boxed `Array< number >` per record. On
+ * tessellated IFC4 models that difference is structural: a large
+ * polygonal-faceset model carries millions of IfcIndexedPolygonalFace
+ * records, and a per-record array for each is the dominant source of
+ * both GC time and retained heap during geometry extraction.
+ */
+export declare class Uint32Sink {
+    private data_;
+    private length_;
+    /**
+     * @param initialCapacity Initial element capacity.
+     */
+    constructor(initialCapacity?: number);
+    /** @return {number} Element count appended since the last reset. */
+    get length(): number;
+    /**
+     * A view of exactly the appended elements. Only valid until the next
+     * append (which may reallocate) — copy it if it must outlive that.
+     *
+     * @return {Uint32Array} View over [0, length).
+     */
+    get view(): Uint32Array;
+    /** Drop all appended elements, keeping the allocated capacity. */
+    reset(): void;
+    /**
+     * Append one value, growing geometrically when full.
+     *
+     * @param value The value to append.
+     */
+    push(value: number): void;
+}
+//# sourceMappingURL=uint32_sink.d.ts.map

package/compiled/src/step/parsing/uint32_sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint32_sink.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/uint32_sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IAErB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,OAAO,CAAY;IAE3B;;OAEG;gBACU,eAAe,GAAE,MAAa;IAI3C,oEAAoE;IACpE,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;OAKG;IACH,IAAW,IAAI,IAAI,WAAW,CAE7B;IAED,kEAAkE;IAC3D,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACI,IAAI,CAAE,KAAK,EAAE,MAAM,GAAI,IAAI;CAanC"}

package/compiled/src/step/parsing/uint32_sink.js

@@ -0,0 +1,50 @@
+/**
+ * Growable Uint32Array append sink.
+ *
+ * Exists so hot extraction loops can parse integer list fields straight
+ * out of the STEP buffer into one reusable typed array, instead of
+ * allocating (and caching) a boxed `Array< number >` per record. On
+ * tessellated IFC4 models that difference is structural: a large
+ * polygonal-faceset model carries millions of IfcIndexedPolygonalFace
+ * records, and a per-record array for each is the dominant source of
+ * both GC time and retained heap during geometry extraction.
+ */
+export class Uint32Sink {
+    /**
+     * @param initialCapacity Initial element capacity.
+     */
+    constructor(initialCapacity = 1024) {
+        this.length_ = 0;
+        this.data_ = new Uint32Array(Math.max(1, initialCapacity));
+    }
+    /** @return {number} Element count appended since the last reset. */
+    get length() {
+        return this.length_;
+    }
+    /**
+     * A view of exactly the appended elements. Only valid until the next
+     * append (which may reallocate) — copy it if it must outlive that.
+     *
+     * @return {Uint32Array} View over [0, length).
+     */
+    get view() {
+        return this.data_.subarray(0, this.length_);
+    }
+    /** Drop all appended elements, keeping the allocated capacity. */
+    reset() {
+        this.length_ = 0;
+    }
+    /**
+     * Append one value, growing geometrically when full.
+     *
+     * @param value The value to append.
+     */
+    push(value) {
+        if (this.length_ === this.data_.length) {
+            const grown = new Uint32Array(this.data_.length * 2);
+            grown.set(this.data_);
+            this.data_ = grown;
+        }
+        this.data_[this.length_++] = value;
+    }
+}

package/compiled/src/step/parsing/uint32_sink.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=uint32_sink.test.d.ts.map

package/compiled/src/step/parsing/uint32_sink.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint32_sink.test.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/uint32_sink.test.ts"],"names":[],"mappings":""}

package/compiled/src/step/parsing/uint32_sink.test.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-magic-numbers */
+// Uint32Sink backs the polygonal-faceset extraction fast path, and
+// extractIntegerArrayInto must stay exactly equivalent to the generated
+// array getters it replaces there — including for a real model's faces.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { IfcAPI } from "../../compat/web-ifc/ifc_api.js";
+import { IfcIndexedPolygonalFace, IfcIndexedPolygonalFaceWithVoids, } from "../../ifc/ifc4_gen/index.js";
+import { Uint32Sink } from "./uint32_sink.js";
+describe("Uint32Sink", () => {
+    test("appends, grows past its initial capacity, and views exactly its length", () => {
+        const sink = new Uint32Sink(2);
+        expect(sink.length).toBe(0);
+        expect(Array.from(sink.view)).toEqual([]);
+        for (let where = 0; where < 10; ++where) {
+            sink.push(where * 3);
+        }
+        expect(sink.length).toBe(10);
+        expect(Array.from(sink.view)).toEqual([0, 3, 6, 9, 12, 15, 18, 21, 24, 27]);
+    });
+    test("reset drops elements but keeps capacity for reuse", () => {
+        const sink = new Uint32Sink(4);
+        sink.push(11);
+        sink.push(22);
+        sink.reset();
+        expect(sink.length).toBe(0);
+        expect(Array.from(sink.view)).toEqual([]);
+        sink.push(33);
+        expect(Array.from(sink.view)).toEqual([33]);
+    });
+});
+describe("extractIntegerArrayInto", () => {
+    let api;
+    let modelID;
+    /**
+     * The faces the extraction fast path actually covers: voided faces
+     * keep the getter path in production, so exclude them here too.
+     *
+     * @return {IfcIndexedPolygonalFace[]} Non-voided faces of the fixture.
+     */
+    function plainFaces() {
+        // The passthrough holds the proxy tuple; the StepModel is its head.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const model = api.models.get(modelID).model[0];
+        return Array.from(model.types(IfcIndexedPolygonalFace))
+            .filter((face) => !(face instanceof IfcIndexedPolygonalFaceWithVoids));
+    }
+    beforeAll(async () => {
+        api = new IfcAPI();
+        await api.Init();
+        modelID = api.OpenModel(new Uint8Array(fs.readFileSync("data/index.ifc")), { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true });
+    }, 120000);
+    test("matches the generated CoordIndex getter on every face of a real model", () => {
+        const faces = plainFaces();
+        expect(faces.length).toBeGreaterThan(0);
+        const sink = new Uint32Sink(4);
+        for (const face of faces) {
+            // The getter caches, so read it first and compare the in-place
+            // parse against it — the fast path must be a drop-in.
+            const expected = face.CoordIndex;
+            sink.reset();
+            const count = face.extractIntegerArrayInto(0, 0, 3, sink);
+            expect(count).toBe(expected.length);
+            expect(Array.from(sink.view)).toEqual(expected);
+        }
+    }, 120000);
+    test("appends consecutively across records into one sink", () => {
+        const faces = plainFaces();
+        const sink = new Uint32Sink(4);
+        const expected = [];
+        for (const face of faces) {
+            face.extractIntegerArrayInto(0, 0, 3, sink);
+            expected.push(...face.CoordIndex);
+        }
+        expect(Array.from(sink.view)).toEqual(expected);
+    }, 120000);
+});

package/compiled/src/step/step_entity_base.d.ts

@@ -3,6 +3,7 @@ import { Entity } from "../core/entity.js";
 import { EntityDescription, EntityFieldsDescription } from "../core/entity_description.js";
 import { EntityFieldDescription } from "../core/entity_field_description.js";
 import { WasmModule } from "../core/native_types.js";
+import { Uint32Sink } from "./parsing/uint32_sink.js";
 import { StepEntityConstructorAbstract } from "./step_entity_constructor.js";
 import StepEntityInternalReference from "./step_entity_internal_reference.js";
 import StepModelBase from "./step_model_base.js";
@@ -307,6 +308,25 @@ export default abstract class StepEntityBase<EntityTypeIDs extends number> imple
      * @return {boolean} True if this extracts, false (usually because this is optional)
      */
     extractParseBuffer(offset: number, baseOffset: number, depth: number, result: ParseBuffer, module: WasmModule, optional: boolean): boolean;
+    /**
+     * Append an unsigned-integer list field straight from the STEP buffer
+     * into `sink`, without materialising an intermediate `Array< number >`.
+     *
+     * Semantically identical to the generated array getters (same
+     * optional handling, same element extraction, same "incorrectly
+     * typed" error), but it neither allocates nor caches a per-record
+     * array — the caller owns one reusable sink for the whole batch. On
+     * tessellated models this removes millions of short-lived arrays and
+     * the retained heap that goes with them; see Uint32Sink.
+     *
+     * @param offset The offset in the vtable to extract from.
+     * @param baseOffset The base offset of the class in the vtable.
+     * @param depth The depth in the inheritance hierarchy.
+     * @param sink Receives the appended values.
+     * @return {number} How many values were appended (0 when the field is
+     * unset/optional-null).
+     */
+    extractIntegerArrayInto(offset: number, baseOffset: number, depth: number, sink: Uint32Sink): number;
     /**
      * Extract a number at the particular vtable offset (i.e. the position
      * in the matching step object).

package/compiled/src/step/step_entity_base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step_entity_base.d.ts","sourceRoot":"","sources":["../../../src/step/step_entity_base.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step_entity_base.d.ts","sourceRoot":"","sources":["../../../src/step/step_entity_base.ts"],"names":[],"mappings":"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"}

package/compiled/src/step/step_entity_base.js

@@ -1,4 +1,4 @@
-import { stepExtractArray, stepExtractBinary, stepExtractBoolean, stepExtractInlineElemement, stepExtractLogical, stepExtractNumber, stepExtractOptional, stepExtractReference, stepExtractString, } from "./parsing/step_deserialization_functions.js";
+import { skipValue, stepExtractArray, stepExtractArrayBegin, stepExtractArrayToken, stepExtractBinary, stepExtractBoolean, stepExtractInlineElemement, stepExtractLogical, stepExtractNumber, stepExtractOptional, stepExtractReference, stepExtractString, } from "./parsing/step_deserialization_functions.js";
 import { stepBufferBase } from "./step_buffer_provider.js";
 var IfcTokenType;
 (function (IfcTokenType) {
@@ -449,6 +449,47 @@ export default class StepEntityBase {
         module.HEAPU8.set(buffer.subarray(cursor, endCursor), dataPtr);
         return true;
     }
+    /**
+     * Append an unsigned-integer list field straight from the STEP buffer
+     * into `sink`, without materialising an intermediate `Array< number >`.
+     *
+     * Semantically identical to the generated array getters (same
+     * optional handling, same element extraction, same "incorrectly
+     * typed" error), but it neither allocates nor caches a per-record
+     * array — the caller owns one reusable sink for the whole batch. On
+     * tessellated models this removes millions of short-lived arrays and
+     * the retained heap that goes with them; see Uint32Sink.
+     *
+     * @param offset The offset in the vtable to extract from.
+     * @param baseOffset The base offset of the class in the vtable.
+     * @param depth The depth in the inheritance hierarchy.
+     * @param sink Receives the appended values.
+     * @return {number} How many values were appended (0 when the field is
+     * unset/optional-null).
+     */
+    extractIntegerArrayInto(offset, baseOffset, depth, sink) {
+        let cursor = this.getOffsetCursor(offset, baseOffset, depth);
+        const buffer = this.buffer;
+        const endCursor = buffer.length;
+        if (stepExtractOptional(buffer, cursor, endCursor) === null) {
+            return 0;
+        }
+        let count = 0;
+        let signedCursor0 = stepExtractArrayBegin(buffer, cursor, endCursor);
+        cursor = Math.abs(signedCursor0);
+        while (signedCursor0 >= 0) {
+            const value = stepExtractNumber(buffer, cursor, endCursor);
+            if (value === void 0) {
+                throw new Error("Value in STEP was incorrectly typed");
+            }
+            cursor = skipValue(buffer, cursor, endCursor);
+            sink.push(value);
+            ++count;
+            signedCursor0 = stepExtractArrayToken(buffer, cursor, endCursor);
+            cursor = Math.abs(signedCursor0);
+        }
+        return count;
+    }
     /**
      * Extract a number at the particular vtable offset (i.e. the position
      * in the matching step object).

package/compiled/src/version/version.js

@@ -5,5 +5,5 @@
 // only the first segment (major) is meaningful and is the one CI carries forward.
 // Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
 // statistics.ts all match `v\d+\.\d+\.\d+`.
-const versionString = 'Conway v1.443.1325';
+const versionString = 'Conway v1.445.1339';
 export { versionString };