@bldrs-ai/conway 1.405.1243 → 1.409.1251

package/compiled/examples/cli-step-bundled.cjs

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.405.1243";
+var versionString = "Conway v1.409.1251";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -18309,8 +18309,8 @@ var StepParser = class extends StepHeaderParser {
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress) {
-    const parser28 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed);
+  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress, sink) {
+    const parser28 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink);
     while (true) {
       const next = parser28.next();
       if (next.done === true) {
@@ -18356,8 +18356,14 @@ var StepParser = class extends StepHeaderParser {
    * @yields {number} The current byte cursor within the input buffer.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed) {
+  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink) {
     const indexResult = { elements: [] };
+    let topLevelCount = 0;
+    const pushEntry = sink !== void 0 ? (entry) => {
+      sink.pushTopLevel(entry);
+    } : (entry) => {
+      indexResult.elements.push(entry);
+    };
     const match = input.match;
     const comment = () => match(commentParser2);
     const whitespace = () => {
@@ -18533,8 +18539,9 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        onRecordIndexed?.(indexResult.elements.length, expressID, 0);
-        indexResult.elements.push({
+        onRecordIndexed?.(topLevelCount, expressID, 0);
+        ++topLevelCount;
+        pushEntry({
           address: startElement2,
           length: input.address - startElement2,
           typeID: 0,
@@ -18625,8 +18632,9 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
-      indexResult.elements.push({
+      onRecordIndexed?.(topLevelCount, expressID, foundItem);
+      ++topLevelCount;
+      pushEntry({
         address: startElement,
         length: input.address - startElement,
         typeID: foundItem,
@@ -20605,6 +20613,31 @@ var StepModelBase = class {
     this.elementMemoization = true;
     this.nullOnErrors = true;
     this.bufferProvider_ = provider ?? new ResidentStepBufferProvider(buffer_);
+    if (!Array.isArray(elementIndex)) {
+      const columns = elementIndex;
+      const firstInline = columns.firstInlineElement;
+      const inlineCount = columns.count - firstInline;
+      const inlineElementTable2 = new Uint32Array(inlineCount << 1);
+      for (let where2 = 0; where2 < inlineCount; ++where2) {
+        inlineElementTable2[where2 << 1] = firstInline + where2;
+        inlineElementTable2[(where2 << 1) + 1] = columns.address[firstInline + where2];
+      }
+      this.inlineAddressMap_ = new InterpolationSearchTable32(inlineElementTable2, true);
+      const expressIdTable2 = new Uint32Array(firstInline << 1);
+      for (let where2 = 0; where2 < firstInline; ++where2) {
+        expressIdTable2[where2 << 1] = where2;
+        expressIdTable2[(where2 << 1) + 1] = columns.expressID[where2];
+      }
+      this.expressIDMap_ = new InterpolationSearchTable32(expressIdTable2, columns.expressIdsSorted);
+      this.address_ = columns.address;
+      this.length_ = columns.length;
+      this.typeID_ = columns.typeID;
+      this.expressID_ = columns.expressID;
+      this.count_ = columns.count;
+      this.firstInlineElement_ = firstInline;
+      this.complexEntries_ = columns.complexEntries;
+      return;
+    }
     const localElementIndex = elementIndex;
     let where = 0;
     const firstInlineElement = localElementIndex.length;
@@ -79760,6 +79793,68 @@ var StepTypeIndexer = class {
   constructor(typeCount) {
     this.elementCounter_ = new Int32Array(typeCount << 1);
   }
+  /**
+   * Create a type index from either index form — the parsed object array or
+   * the columnar index (M7).
+   *
+   * @param index The element index, object or columnar.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFor(index) {
+    return Array.isArray(index) ? this.create(index) : this.createFromColumns(index);
+  }
+  /**
+   * Create a type index straight from the columnar index — the same
+   * membership `create` produces from the unfolded object array: every row's
+   * concrete type (top-level + inline; −1 rows skipped) plus the
+   * multi-mapping subtypes of retained complex entries at their parent's
+   * dense index.
+   *
+   * @param columns The columnar index.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFromColumns(columns) {
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const elementCounter = this.elementCounter_;
+    const prefixSum = new Uint32Array((this.elementCounter_.length >>> 1) + 1);
+    const typeIDs = columns.typeID;
+    const count = columns.count;
+    const walkRows = (addOne) => {
+      const complexIterator = columns.complexEntries?.entries();
+      let nextComplex = complexIterator?.next();
+      for (let denseIndex = 0; denseIndex < count; ++denseIndex) {
+        const typeID = typeIDs[denseIndex];
+        if (typeID >= 0) {
+          addOne(denseIndex, typeID);
+        }
+        if (nextComplex !== void 0 && !nextComplex.done && nextComplex.value[0] === denseIndex) {
+          for (const subElement of nextComplex.value[1].multiMapping ?? []) {
+            const subTypeID = subElement.typeID;
+            if (subTypeID !== void 0) {
+              addOne(denseIndex, subTypeID);
+            }
+          }
+          nextComplex = complexIterator.next();
+        }
+      }
+    };
+    walkRows((denseIndex, typeID) => {
+      prefixSum[typeID + 1] = addCompactedElementCount32State(denseIndex, elementCounter, typeID << 1);
+    });
+    for (let prefixSumIndex = 2, prefixSumEnd = prefixSum.length; prefixSumIndex < prefixSumEnd; ++prefixSumIndex) {
+      prefixSum[prefixSumIndex] += prefixSum[prefixSumIndex - 1];
+    }
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const indexOutput = new Uint32Array(prefixSum[prefixSum.length - 1] << 1);
+    walkRows((denseIndex, typeID) => {
+      addCompactedElement32State(denseIndex, elementCounter, indexOutput, typeID << 1, prefixSum[typeID] << 1);
+    });
+    return new MultiIndexSet(prefixSum, indexOutput);
+  }
   /**
    * Create a type index from a set of parsed STEP elements.
    *
@@ -80319,7 +80414,7 @@ var AP214StepModel = class extends StepModelBase {
     this.profiles = new AP214ModelProfile();
     this.curves = new AP214ModelCurves(this);
     this.csgOperations = new CsgMemoization();
-    this.typeIndex = indexerInstance.create(elementIndex);
+    this.typeIndex = indexerInstance.createFor(elementIndex);
   }
 };
 

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.405.1243";
+var versionString = "Conway v1.409.1251";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -3501,8 +3501,8 @@ var StepParser = class extends StepHeaderParser {
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress) {
-    const parser211 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed);
+  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress, sink) {
+    const parser211 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink);
     while (true) {
       const next = parser211.next();
       if (next.done === true) {
@@ -3548,8 +3548,14 @@ var StepParser = class extends StepHeaderParser {
    * @yields {number} The current byte cursor within the input buffer.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed) {
+  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink) {
     const indexResult = { elements: [] };
+    let topLevelCount = 0;
+    const pushEntry = sink !== void 0 ? (entry) => {
+      sink.pushTopLevel(entry);
+    } : (entry) => {
+      indexResult.elements.push(entry);
+    };
     const match = input.match;
     const comment = () => match(commentParser2);
     const whitespace = () => {
@@ -3725,8 +3731,9 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
-        onRecordIndexed?.(indexResult.elements.length, expressID, 0);
-        indexResult.elements.push({
+        onRecordIndexed?.(topLevelCount, expressID, 0);
+        ++topLevelCount;
+        pushEntry({
           address: startElement2,
           length: input.address - startElement2,
           typeID: 0,
@@ -3817,8 +3824,9 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
-      onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
-      indexResult.elements.push({
+      onRecordIndexed?.(topLevelCount, expressID, foundItem);
+      ++topLevelCount;
+      pushEntry({
         address: startElement,
         length: input.address - startElement,
         typeID: foundItem,
@@ -4998,6 +5006,31 @@ var StepModelBase = class {
     this.elementMemoization = true;
     this.nullOnErrors = true;
     this.bufferProvider_ = provider ?? new ResidentStepBufferProvider(buffer_);
+    if (!Array.isArray(elementIndex)) {
+      const columns = elementIndex;
+      const firstInline = columns.firstInlineElement;
+      const inlineCount = columns.count - firstInline;
+      const inlineElementTable2 = new Uint32Array(inlineCount << 1);
+      for (let where2 = 0; where2 < inlineCount; ++where2) {
+        inlineElementTable2[where2 << 1] = firstInline + where2;
+        inlineElementTable2[(where2 << 1) + 1] = columns.address[firstInline + where2];
+      }
+      this.inlineAddressMap_ = new InterpolationSearchTable32(inlineElementTable2, true);
+      const expressIdTable2 = new Uint32Array(firstInline << 1);
+      for (let where2 = 0; where2 < firstInline; ++where2) {
+        expressIdTable2[where2 << 1] = where2;
+        expressIdTable2[(where2 << 1) + 1] = columns.expressID[where2];
+      }
+      this.expressIDMap_ = new InterpolationSearchTable32(expressIdTable2, columns.expressIdsSorted);
+      this.address_ = columns.address;
+      this.length_ = columns.length;
+      this.typeID_ = columns.typeID;
+      this.expressID_ = columns.expressID;
+      this.count_ = columns.count;
+      this.firstInlineElement_ = firstInline;
+      this.complexEntries_ = columns.complexEntries;
+      return;
+    }
     const localElementIndex = elementIndex;
     let where = 0;
     const firstInlineElement = localElementIndex.length;
@@ -70115,6 +70148,68 @@ var StepTypeIndexer = class {
   constructor(typeCount) {
     this.elementCounter_ = new Int32Array(typeCount << 1);
   }
+  /**
+   * Create a type index from either index form — the parsed object array or
+   * the columnar index (M7).
+   *
+   * @param index The element index, object or columnar.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFor(index) {
+    return Array.isArray(index) ? this.create(index) : this.createFromColumns(index);
+  }
+  /**
+   * Create a type index straight from the columnar index — the same
+   * membership `create` produces from the unfolded object array: every row's
+   * concrete type (top-level + inline; −1 rows skipped) plus the
+   * multi-mapping subtypes of retained complex entries at their parent's
+   * dense index.
+   *
+   * @param columns The columnar index.
+   * @return {MultiIndexSet} The created multi-set index.
+   */
+  createFromColumns(columns) {
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const elementCounter = this.elementCounter_;
+    const prefixSum = new Uint32Array((this.elementCounter_.length >>> 1) + 1);
+    const typeIDs = columns.typeID;
+    const count = columns.count;
+    const walkRows = (addOne) => {
+      const complexIterator = columns.complexEntries?.entries();
+      let nextComplex = complexIterator?.next();
+      for (let denseIndex = 0; denseIndex < count; ++denseIndex) {
+        const typeID = typeIDs[denseIndex];
+        if (typeID >= 0) {
+          addOne(denseIndex, typeID);
+        }
+        if (nextComplex !== void 0 && !nextComplex.done && nextComplex.value[0] === denseIndex) {
+          for (const subElement of nextComplex.value[1].multiMapping ?? []) {
+            const subTypeID = subElement.typeID;
+            if (subTypeID !== void 0) {
+              addOne(denseIndex, subTypeID);
+            }
+          }
+          nextComplex = complexIterator.next();
+        }
+      }
+    };
+    walkRows((denseIndex, typeID) => {
+      prefixSum[typeID + 1] = addCompactedElementCount32State(denseIndex, elementCounter, typeID << 1);
+    });
+    for (let prefixSumIndex = 2, prefixSumEnd = prefixSum.length; prefixSumIndex < prefixSumEnd; ++prefixSumIndex) {
+      prefixSum[prefixSumIndex] += prefixSum[prefixSumIndex - 1];
+    }
+    for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+      initCountCompactedElements32State(this.elementCounter_, where);
+    }
+    const indexOutput = new Uint32Array(prefixSum[prefixSum.length - 1] << 1);
+    walkRows((denseIndex, typeID) => {
+      addCompactedElement32State(denseIndex, elementCounter, indexOutput, typeID << 1, prefixSum[typeID] << 1);
+    });
+    return new MultiIndexSet(prefixSum, indexOutput);
+  }
   /**
    * Create a type index from a set of parsed STEP elements.
    *
@@ -70776,12 +70871,136 @@ var IfcStepModel = class extends StepModelBase {
     this.materials = new IfcMaterialCache(this);
     this.voidMaterials = new IfcMaterialCache(this, true);
     this.elementTypeIDs = entity_types_ifc_gen_default;
-    this.typeIndex = indexerInstance.create(elementIndex);
+    this.typeIndex = indexerInstance.createFor(elementIndex);
   }
 };
 
+// compiled/src/step/parsing/columnar_index.js
+var COLUMN_UNDEFINED_TYPE = -1;
+var SEGMENT_ROWS = 64 * 1024;
+var ColumnarIndexSink = class {
+  constructor() {
+    this.segments_ = [];
+    this.count_ = 0;
+    this.retained_ = /* @__PURE__ */ new Map();
+    this.expressIdsSorted_ = true;
+    this.previousExpressID_ = 0;
+  }
+  /**
+   * @return {number} Top-level records pushed so far.
+   */
+  get topLevelCount() {
+    return this.count_;
+  }
+  /**
+   * Encode one completed top-level record into the columns. The entry object
+   * is not kept unless it carries children (inline entities / multi-mapping).
+   *
+   * @param entry The completed top-level index entry.
+   */
+  pushTopLevel(entry) {
+    const localID = this.count_++;
+    const segmentIndex = Math.floor(localID / SEGMENT_ROWS);
+    const row = localID % SEGMENT_ROWS;
+    if (segmentIndex === this.segments_.length) {
+      this.segments_.push({
+        address: new Uint32Array(SEGMENT_ROWS),
+        length: new Uint32Array(SEGMENT_ROWS),
+        typeID: new Int32Array(SEGMENT_ROWS),
+        expressID: new Uint32Array(SEGMENT_ROWS)
+      });
+    }
+    const segment = this.segments_[segmentIndex];
+    segment.address[row] = entry.address;
+    segment.length[row] = entry.length;
+    segment.typeID[row] = entry.typeID === void 0 ? COLUMN_UNDEFINED_TYPE : entry.typeID;
+    segment.expressID[row] = entry.expressID;
+    if (entry.expressID < this.previousExpressID_) {
+      this.expressIdsSorted_ = false;
+    }
+    this.previousExpressID_ = entry.expressID;
+    if (entry.inlineEntities !== void 0 || entry.multiMapping !== void 0) {
+      this.retained_.set(localID, entry);
+    }
+  }
+  /**
+   * Rewind to empty (the streaming builder's grow-and-restart). The first
+   * segment is kept for reuse.
+   */
+  reset() {
+    this.segments_.length = Math.min(this.segments_.length, 1);
+    this.count_ = 0;
+    this.retained_.clear();
+    this.expressIdsSorted_ = true;
+    this.previousExpressID_ = 0;
+  }
+  /**
+   * Assemble the final columns: concatenate the top-level segments (one
+   * column at a time, bounding transient overhead to a single column's
+   * segments) and unfold retained inline entities into the inline range in
+   * the model's exact unfold order.
+   *
+   * @return {StepIndexColumns} The finished columnar index.
+   */
+  finalize() {
+    const topLevel = this.count_;
+    const unfolded = [];
+    for (const entry of this.retained_.values()) {
+      if (entry.inlineEntities !== void 0) {
+        unfolded.push(...entry.inlineEntities);
+      }
+    }
+    for (let where = 0; where < unfolded.length; ++where) {
+      const inlineEntities = unfolded[where].inlineEntities;
+      if (inlineEntities !== void 0) {
+        unfolded.push(...inlineEntities);
+      }
+    }
+    const count = topLevel + unfolded.length;
+    const address = concatColumn(this.segments_, "address", topLevel, count);
+    const length = concatColumn(this.segments_, "length", topLevel, count);
+    const typeID = new Int32Array(count);
+    for (let segment = 0; segment * SEGMENT_ROWS < topLevel; ++segment) {
+      const rows = Math.min(SEGMENT_ROWS, topLevel - segment * SEGMENT_ROWS);
+      typeID.set(this.segments_[segment].typeID.subarray(0, rows), segment * SEGMENT_ROWS);
+    }
+    const expressID = concatColumn(this.segments_, "expressID", topLevel, topLevel);
+    for (let where = 0; where < unfolded.length; ++where) {
+      const entry = unfolded[where];
+      const row = topLevel + where;
+      address[row] = entry.address;
+      length[row] = entry.length;
+      typeID[row] = entry.typeID === void 0 ? COLUMN_UNDEFINED_TYPE : entry.typeID;
+    }
+    let complexEntries;
+    for (const [localID, entry] of this.retained_) {
+      if (entry.multiMapping !== void 0) {
+        (complexEntries ??= /* @__PURE__ */ new Map()).set(localID, entry);
+      }
+    }
+    return {
+      address,
+      length,
+      typeID,
+      expressID,
+      count,
+      firstInlineElement: topLevel,
+      complexEntries,
+      expressIdsSorted: this.expressIdsSorted_
+    };
+  }
+};
+function concatColumn(segments, column, rows, finalLength) {
+  const result = new Uint32Array(finalLength);
+  for (let segment = 0; segment * SEGMENT_ROWS < rows; ++segment) {
+    const valid = Math.min(SEGMENT_ROWS, rows - segment * SEGMENT_ROWS);
+    result.set(segments[segment][column].subarray(0, valid), segment * SEGMENT_ROWS);
+  }
+  return result;
+}
+
 // compiled/src/step/parsing/streaming_index_builder.js
-function buildIndexStreaming(source, parser211, pool3, onRecordIndexed) {
+function buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink) {
   const fileSize = source.byteLength;
   let windowBytes = Math.max(pool3, MIN_WINDOW);
   for (; ; ) {
@@ -70827,11 +71046,12 @@ function buildIndexStreaming(source, parser211, pool3, onRecordIndexed) {
       buffer.rebaseWindow(window2, 0, windowLen, windowStartFile);
       ++slides;
     };
-    const [index, result] = parser211.parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed);
+    const [index, result] = parser211.parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, void 0, sink);
     const stoppedShort = result !== ParseResult.COMPLETE;
     const notAtEof = windowStartFile + windowLen < fileSize;
     if (stoppedShort && notAtEof) {
       windowBytes *= 2;
+      sink?.reset();
       continue;
     }
     const lastRecordLen = windowStartFile + input.cursor - prevBoundaryFile;
@@ -70847,6 +71067,11 @@ function buildIndexStreaming(source, parser211, pool3, onRecordIndexed) {
   }
 }
 var MIN_WINDOW = 4 * 1024;
+function buildColumnarIndexStreaming(source, parser211, pool3, onRecordIndexed) {
+  const sink = new ColumnarIndexSink();
+  const { header, result, stats } = buildIndexStreaming(source, parser211, pool3, onRecordIndexed, sink);
+  return { header, columns: sink.finalize(), result, stats };
+}
 
 // compiled/src/ifc/ifc_step_parser.js
 var DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
@@ -70912,9 +71137,9 @@ var IfcStepParser = class extends StepParser {
     if (store.byteLength !== source.byteLength) {
       throw new Error(`Streaming store byteLength ${store.byteLength} does not match source byteLength ${source.byteLength}`);
     }
-    const { elements, result } = buildIndexStreaming(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES);
+    const { columns, result } = buildColumnarIndexStreaming(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES);
     const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
-    return [result, new IfcStepModel(void 0, elements, provider)];
+    return [result, new IfcStepModel(void 0, columns, provider)];
   }
 };
 IfcStepParser.Instance = new IfcStepParser();

package/compiled/src/AP214E3_2010/ap214_step_model.d.ts

@@ -1,6 +1,7 @@
 import EntityTypesAP214 from "./AP214E3_2010_gen/entity_types_ap214.gen.js";
 import StepModelBase from "../step/step_model_base.js";
 import { StepIndexEntry } from "../step/parsing/step_parser.js";
+import { StepIndexColumns } from "../step/parsing/columnar_index.js";
 import { MultiIndexSet } from "../indexing/multi_index_set.js";
 import { AP214ModelGeometry } from "./ap214_model_geometry.js";
 import { AP214ModelProfile } from "./ap214_model_profile.js";
@@ -26,6 +27,6 @@ export default class AP214StepModel extends StepModelBase<EntityTypesAP214> {
      * @param buffer The buffer to values from.
      * @param elementIndex The parsed index to elements in the STEP.
      */
-    constructor(buffer: Uint8Array, elementIndex: StepIndexEntry<EntityTypesAP214>[]);
+    constructor(buffer: Uint8Array, elementIndex: StepIndexEntry<EntityTypesAP214>[] | StepIndexColumns<EntityTypesAP214>);
 }
 //# sourceMappingURL=ap214_step_model.d.ts.map

package/compiled/src/AP214E3_2010/ap214_step_model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ap214_step_model.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAyC,MAAM,2CAA2C,CAAA;AACjG,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,wBAAwB,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,gBAAgB,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,aAAa,CAAE,gBAAgB,CAAE;IAE3E,SAAgB,SAAS,EAAE,aAAa,CAAE,gBAAgB,CAAE,CAAA;IAC5D,SAAgB,mBAAmB,kCAA2B;IAC9D,SAAgB,QAAQ,qBAA2B;IACnD,SAAgB,SAAS,qBAA2B;IACpD,SAAgB,QAAQ,oBAA0B;IAClD,SAAgB,MAAM,mBAA6B;IACnD,SAAgB,aAAa,iBAAuB;IAEpD;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,gBAAgB,CAAE,EAAE;CAKvD"}
+{"version":3,"file":"ap214_step_model.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAyC,MAAM,2CAA2C,CAAA;AACjG,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAA;AAE/D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,wBAAwB,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,gBAAgB,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,aAAa,CAAE,gBAAgB,CAAE;IAE3E,SAAgB,SAAS,EAAE,aAAa,CAAE,gBAAgB,CAAE,CAAA;IAC5D,SAAgB,mBAAmB,kCAA2B;IAC9D,SAAgB,QAAQ,qBAA2B;IACnD,SAAgB,SAAS,qBAA2B;IACpD,SAAgB,QAAQ,oBAA0B;IAClD,SAAgB,MAAM,mBAA6B;IACnD,SAAgB,aAAa,iBAAuB;IAEpD;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,gBAAgB,CAAE,EAAE,GAAG,gBAAgB,CAAE,gBAAgB,CAAE;CAK9F"}

package/compiled/src/AP214E3_2010/ap214_step_model.js

@@ -28,6 +28,6 @@ export default class AP214StepModel extends StepModelBase {
         this.profiles = new AP214ModelProfile();
         this.curves = new AP214ModelCurves(this);
         this.csgOperations = new CsgMemoization();
-        this.typeIndex = indexerInstance.create(elementIndex);
+        this.typeIndex = indexerInstance.createFor(elementIndex);
     }
 }

package/compiled/src/core/geometry_tile_pool.d.ts

@@ -0,0 +1,99 @@
+import { GeometryTiles } from "./demand_geometry_queue.js";
+import { ChunkedPool } from "./mem/chunked_pool.js";
+import { SharedAssetPool } from "./mem/shared_asset_pool.js";
+/**
+ * One shareable geometry payload an instance needs resident: the asset's
+ * identity and its byte size. For IFC, the asset is a representation's
+ * tessellated geometry and `byteSize` comes from the wasm-side extract.
+ */
+export interface GeometryAsset<AssetID> {
+    assetID: AssetID;
+    byteSize: number;
+}
+/**
+ * The domain half the tile pool delegates to: what assets an instance is made
+ * of, and how to materialise / discard one asset's payload. This is the seam
+ * the production conway-geom surface implements (extract → tessellate into
+ * the asset's chunks; discard on last release); tests implement it with
+ * recording mocks.
+ */
+export interface InstanceAssetSource<AssetID> {
+    /**
+     * The assets an instance requires resident, with their byte sizes. For a
+     * simple product this is one asset; mapped/instanced representations return
+     * the same assetID from many instances — that sharing is the point.
+     *
+     * @param instanceID The instance (product local ID in the geometry case).
+     * @return {GeometryAsset<AssetID>[]} The instance's assets.
+     */
+    assetsOf(instanceID: number): GeometryAsset<AssetID>[];
+    /**
+     * Materialise an asset's payload (called exactly once per residency, on
+     * the 0→1 reference). In production: run the wasm extract/tessellate and
+     * write the result into the asset's pool chunks.
+     *
+     * @param assetID The asset to materialise.
+     */
+    materialize(assetID: AssetID): void;
+    /**
+     * Discard an asset's payload (called exactly once per residency, on the
+     * 1→0 reference, after its chunks are already back in the pool).
+     *
+     * @param assetID The asset to discard.
+     */
+    discard(assetID: AssetID): void;
+}
+/**
+ * The geometry narrowing of the general memory system (`src/core/mem/`): a
+ * {@link GeometryTiles} backend where a product's "tile" is a set of
+ * refcounted, chunk-resident **assets** in a {@link SharedAssetPool}.
+ *
+ * Composed with {@link DemandGeometryQueue} this completes the M3 resident
+ * design: the queue owns demand ordering and the logical budget; this pool
+ * owns physical residency. Two accounting views, one invariant:
+ *
+ * - **Logical (queue-side):** `extract` charges an instance the full
+ *   chunk-rounded cost of *every* asset it references, shared or not. Sharing
+ *   is thus double-charged logically — deliberately conservative: summed
+ *   logical charges always cover physical use, so with the queue's budget set
+ *   to the pool's budget, an acquire can never fail mid-extract. (Heavy
+ *   sharing under-utilises the logical budget; the production wiring can
+ *   widen the queue budget once measured. The safe direction first.)
+ * - **Physical (pool-side):** `bytesInUse` counts real chunks. Shared assets
+ *   are stored once, refcounted, and freed only on the last release — so
+ *   evicting product A never discards the representation product B still
+ *   renders (the mapped-item correctness rule, held structurally).
+ */
+export declare class GeometryTilePool<AssetID> implements GeometryTiles {
+    private readonly assets_;
+    private readonly source_;
+    /** Assets each extracted instance holds references on. */
+    private readonly held_;
+    /**
+     * @param pool The chunk pool residents live in.
+     * @param source The domain half (asset composition + materialise/discard).
+     */
+    constructor(pool: ChunkedPool, source: InstanceAssetSource<AssetID>);
+    /**
+     * @return {SharedAssetPool<AssetID>} The refcounted asset layer (physical
+     * accounting lives here / on its pool).
+     */
+    get assets(): SharedAssetPool<AssetID>;
+    /**
+     * Materialise an instance's tile: take a reference on each of its assets,
+     * materialising the ones not yet resident.
+     *
+     * @param instanceID The instance (product local ID).
+     * @return {number} The instance's logical byte cost (chunk-rounded, every
+     * asset fully charged — see class docs for why sharing is double-charged).
+     */
+    extract(instanceID: number): number;
+    /**
+     * Release an instance's tile: drop the reference on each of its assets,
+     * discarding those this instance was the last holder of.
+     *
+     * @param instanceID The instance (product local ID).
+     */
+    release(instanceID: number): void;
+}
+//# sourceMappingURL=geometry_tile_pool.d.ts.map

package/compiled/src/core/geometry_tile_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_tile_pool.d.ts","sourceRoot":"","sources":["../../../src/core/geometry_tile_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAGzD;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,OAAO;IACpC,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAGD;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB,CAAC,OAAO;IAE1C;;;;;;;OAOG;IACH,QAAQ,CAAE,UAAU,EAAE,MAAM,GAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAA;IAExD;;;;;;OAMG;IACH,WAAW,CAAE,OAAO,EAAE,OAAO,GAAI,IAAI,CAAA;IAErC;;;;;OAKG;IACH,OAAO,CAAE,OAAO,EAAE,OAAO,GAAI,IAAI,CAAA;CAClC;AAGD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAgB,CAAC,OAAO,CAAE,YAAW,aAAa;IAE7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAElD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAEtD,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8C;IAEpE;;;OAGG;gBACU,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,CAAC,OAAO,CAAC;IAKpE;;;OAGG;IACH,IAAW,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC,CAE5C;IAED;;;;;;;OAOG;IACI,OAAO,CAAE,UAAU,EAAE,MAAM,GAAI,MAAM;IAoD5C;;;;;OAKG;IACI,OAAO,CAAE,UAAU,EAAE,MAAM,GAAI,IAAI;CAgB3C"}