@bldrs-ai/conway 1.519.1471 → 1.520.1486

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.519.1471";
+var versionString = "Conway v1.520.1486";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -11065,6 +11065,67 @@ function IfcWorkScheduleTypeEnumDeserializeStep(input2, cursor, endCursor) {
   return parser208.extract(IfcWorkScheduleTypeEnumSearch, input2, cursor, endCursor);
 }
 
+// compiled/src/core/wasm_heap.js
+function describeHeap(wasmModule, arrayPtr, numBytes) {
+  const heap = wasmModule.HEAPU8;
+  const buffer = currentHeapBuffer(wasmModule);
+  const shared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+  const kind = buffer === void 0 ? "none" : shared ? "SharedArrayBuffer" : "ArrayBuffer";
+  const extensible = shared ? buffer?.growable : buffer?.resizable;
+  return `ptr ${arrayPtr} + ${numBytes} bytes, heap view length ${heap?.length}, buffer ${kind} byteLength ${buffer?.byteLength}, extensible ${extensible}`;
+}
+function currentHeapBuffer(wasmModule) {
+  const memory = wasmModule.wasmMemory;
+  return memory !== void 0 ? memory.buffer : wasmModule.HEAPU8?.buffer;
+}
+function refreshHeapViews(wasmModule) {
+  if (typeof wasmModule.updateMemoryViews === "function") {
+    wasmModule.updateMemoryViews();
+    return;
+  }
+  if (wasmModule.wasmMemory !== void 0) {
+    return;
+  }
+  const StringVector = wasmModule.stringVector;
+  if (StringVector === void 0) {
+    return;
+  }
+  let scratch;
+  releaseQuietly(() => {
+    const created2 = new StringVector();
+    scratch = created2;
+    created2.push_back("");
+  });
+  const created = scratch;
+  if (created !== void 0) {
+    releaseQuietly(() => created.delete());
+  }
+}
+function reconcileHeapBuffer(wasmModule, address, numBytes) {
+  const buffer = currentHeapBuffer(wasmModule);
+  if (buffer !== void 0 && address + numBytes <= buffer.byteLength) {
+    return buffer;
+  }
+  refreshHeapViews(wasmModule);
+  const refreshed = currentHeapBuffer(wasmModule);
+  if (refreshed !== void 0 && address + numBytes <= refreshed.byteLength) {
+    return refreshed;
+  }
+  throw new Error("wasm heap allocation lies outside the heap, and refreshing the module views did not reconcile it. " + describeHeap(wasmModule, address, numBytes));
+}
+function wasmHeapView(wasmModule, arrayType, pointer, elementCount) {
+  const address = pointer >>> 0;
+  const numBytes = elementCount * arrayType.BYTES_PER_ELEMENT;
+  return new arrayType(reconcileHeapBuffer(wasmModule, address, numBytes), address, elementCount);
+}
+function releaseQuietly(release) {
+  try {
+    release();
+  } catch (error) {
+    logger_default.debug(`wasm resource release failed during teardown: ${error instanceof Error ? error.message : error}`);
+  }
+}
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -11500,8 +11561,9 @@ var StepEntityBase = class {
     if (optional && stepExtractOptional(buffer, cursor, endCursor) === null) {
       return false;
     }
-    const dataPtr = result.resize(endCursor - cursor);
-    module2.HEAPU8.set(buffer.subarray(cursor, endCursor), dataPtr);
+    const length = endCursor - cursor;
+    const dataPtr = result.resize(length);
+    wasmHeapView(module2, Uint8Array, dataPtr, length).set(buffer.subarray(cursor, endCursor));
     return true;
   }
   /**

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.519.1471";
+var versionString = "Conway v1.520.1486";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -26948,6 +26948,121 @@ function IfcWorkScheduleTypeEnumDeserializeStep(input, cursor, endCursor) {
   return parser208.extract(IfcWorkScheduleTypeEnumSearch, input, cursor, endCursor);
 }
 
+// compiled/src/core/wasm_heap.js
+function describeHeap(wasmModule, arrayPtr, numBytes) {
+  const heap = wasmModule.HEAPU8;
+  const buffer = currentHeapBuffer(wasmModule);
+  const shared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+  const kind = buffer === void 0 ? "none" : shared ? "SharedArrayBuffer" : "ArrayBuffer";
+  const extensible = shared ? buffer?.growable : buffer?.resizable;
+  return `ptr ${arrayPtr} + ${numBytes} bytes, heap view length ${heap?.length}, buffer ${kind} byteLength ${buffer?.byteLength}, extensible ${extensible}`;
+}
+function currentHeapBuffer(wasmModule) {
+  const memory = wasmModule.wasmMemory;
+  return memory !== void 0 ? memory.buffer : wasmModule.HEAPU8?.buffer;
+}
+function refreshHeapViews(wasmModule) {
+  if (typeof wasmModule.updateMemoryViews === "function") {
+    wasmModule.updateMemoryViews();
+    return;
+  }
+  if (wasmModule.wasmMemory !== void 0) {
+    return;
+  }
+  const StringVector = wasmModule.stringVector;
+  if (StringVector === void 0) {
+    return;
+  }
+  let scratch;
+  releaseQuietly(() => {
+    const created2 = new StringVector();
+    scratch = created2;
+    created2.push_back("");
+  });
+  const created = scratch;
+  if (created !== void 0) {
+    releaseQuietly(() => created.delete());
+  }
+}
+function reconcileHeapBuffer(wasmModule, address, numBytes) {
+  const buffer = currentHeapBuffer(wasmModule);
+  if (buffer !== void 0 && address + numBytes <= buffer.byteLength) {
+    return buffer;
+  }
+  refreshHeapViews(wasmModule);
+  const refreshed = currentHeapBuffer(wasmModule);
+  if (refreshed !== void 0 && address + numBytes <= refreshed.byteLength) {
+    return refreshed;
+  }
+  throw new Error("wasm heap allocation lies outside the heap, and refreshing the module views did not reconcile it. " + describeHeap(wasmModule, address, numBytes));
+}
+function wasmHeapView(wasmModule, arrayType, pointer, elementCount) {
+  const address = pointer >>> 0;
+  const numBytes = elementCount * arrayType.BYTES_PER_ELEMENT;
+  return new arrayType(reconcileHeapBuffer(wasmModule, address, numBytes), address, elementCount);
+}
+function arrayToWasmHeap(wasmModule, array) {
+  const numBytes = array.length * array.BYTES_PER_ELEMENT;
+  const arrayPtr = wasmModule._malloc(numBytes) >>> 0;
+  if (arrayPtr === 0 && numBytes > 0) {
+    throw new Error(`wasm _malloc returned an unusable address for ${numBytes} bytes - ` + describeHeap(wasmModule, arrayPtr, numBytes));
+  }
+  let destination;
+  try {
+    destination = wasmHeapView(wasmModule, Uint8Array, arrayPtr, numBytes);
+  } catch (error) {
+    releaseQuietly(() => wasmModule._free(arrayPtr));
+    throw error;
+  }
+  destination.set(new Uint8Array(array.buffer, array.byteOffset, numBytes));
+  return arrayPtr;
+}
+function arraysToWasmHeap(wasmModule, arrays) {
+  const pointers = [];
+  try {
+    for (const array of arrays) {
+      pointers.push(arrayToWasmHeap(wasmModule, array));
+    }
+  } catch (error) {
+    for (const pointer of pointers) {
+      releaseQuietly(() => wasmModule._free(pointer));
+    }
+    throw error;
+  }
+  return pointers;
+}
+function releaseQuietly(release) {
+  try {
+    release();
+  } catch (error) {
+    logger_default.debug(`wasm resource release failed during teardown: ${error instanceof Error ? error.message : error}`);
+  }
+}
+function withRelease(body, release) {
+  let result;
+  try {
+    result = body();
+  } catch (error) {
+    releaseQuietly(release);
+    throw error;
+  }
+  release();
+  return result;
+}
+function freeAll(wasmModule, pointers) {
+  let firstFailure;
+  for (const pointer of pointers) {
+    try {
+      wasmModule._free(pointer);
+    } catch (error) {
+      firstFailure ??= error;
+    }
+  }
+  if (firstFailure !== void 0) {
+    throw firstFailure;
+  }
+}
+
 // compiled/src/step/step_entity_base.js
 var IfcTokenType;
 (function(IfcTokenType2) {
@@ -27383,8 +27498,9 @@ var StepEntityBase = class {
     if (optional && stepExtractOptional(buffer, cursor, endCursor) === null) {
       return false;
     }
-    const dataPtr = result.resize(endCursor - cursor);
-    module2.HEAPU8.set(buffer.subarray(cursor, endCursor), dataPtr);
+    const length = endCursor - cursor;
+    const dataPtr = result.resize(length);
+    wasmHeapView(module2, Uint8Array, dataPtr, length).set(buffer.subarray(cursor, endCursor));
     return true;
   }
   /**
@@ -88642,83 +88758,15 @@ var IfcSceneBuilder = class {
   }
 };
 
-// compiled/src/core/wasm_heap.js
-function describeHeap(wasmModule, arrayPtr, numBytes) {
-  const heap = wasmModule.HEAPU8;
-  const buffer = heap?.buffer;
-  const shared = typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
-  const kind = buffer === void 0 ? "none" : shared ? "SharedArrayBuffer" : "ArrayBuffer";
-  const extensible = shared ? buffer?.growable : buffer?.resizable;
-  return `ptr ${arrayPtr} + ${numBytes} bytes, heap view length ${heap?.length}, buffer ${kind} byteLength ${buffer?.byteLength}, extensible ${extensible}`;
-}
-function arrayToWasmHeap(wasmModule, array) {
-  const numBytes = array.length * array.BYTES_PER_ELEMENT;
-  const arrayPtr = wasmModule._malloc(numBytes) >>> 0;
-  if (arrayPtr === 0 && numBytes > 0) {
-    throw new Error(`wasm _malloc returned an unusable address for ${numBytes} bytes - ` + describeHeap(wasmModule, arrayPtr, numBytes));
-  }
-  const heapBuffer = wasmModule.HEAPU8.buffer;
-  if (arrayPtr + numBytes > heapBuffer.byteLength) {
-    const description = describeHeap(wasmModule, arrayPtr, numBytes);
-    releaseQuietly(() => wasmModule._free(arrayPtr));
-    throw new Error(`wasm heap allocation lies outside the heap view - the view is stale or the heap grew without it. ${description}`);
-  }
-  const destination = new Uint8Array(heapBuffer, arrayPtr, numBytes);
-  destination.set(new Uint8Array(array.buffer, array.byteOffset, numBytes));
-  return arrayPtr;
-}
-function arraysToWasmHeap(wasmModule, arrays) {
-  const pointers = [];
-  try {
-    for (const array of arrays) {
-      pointers.push(arrayToWasmHeap(wasmModule, array));
-    }
-  } catch (error) {
-    for (const pointer of pointers) {
-      releaseQuietly(() => wasmModule._free(pointer));
-    }
-    throw error;
-  }
-  return pointers;
-}
-function releaseQuietly(release) {
-  try {
-    release();
-  } catch (error) {
-    logger_default.debug(`wasm resource release failed during teardown: ${error instanceof Error ? error.message : error}`);
-  }
-}
-function withRelease(body, release) {
-  let result;
-  try {
-    result = body();
-  } catch (error) {
-    releaseQuietly(release);
-    throw error;
-  }
-  release();
-  return result;
-}
-function freeAll(wasmModule, pointers) {
-  let firstFailure;
-  for (const pointer of pointers) {
-    try {
-      wasmModule._free(pointer);
-    } catch (error) {
-      firstFailure ??= error;
-    }
-  }
-  if (firstFailure !== void 0) {
-    throw firstFailure;
-  }
-}
-
 // compiled/src/ifc/ifc_parser_quirks.js
 var MATERIAL_RELATED_OBJECTS_PERMISSIVE = true;
 var REFLECTANCE_METHOD_PERMISSIVE = true;
 
 // compiled/src/ifc/ifc_geometry_extraction.js
 var DEFAULT_GEOMETRY_YIELD_INTERVAL_MS = 50;
+var GRID_INTERSECTION_AXIS_COUNT = 2;
+var GRID_INTERSECTION_Z_OFFSET = 2;
+var GRID_AXIS_PARALLEL_EPSILON = 1e-9;
 function extractSpecularHighlight(from) {
   if (from === null) {
     return void 0;
@@ -91135,7 +91183,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       pointer = this.wasmModule._malloc(numBytes);
       capacity = maxPossibleFloats;
     }
-    const wasmFloat64View = this.wasmModule.HEAPF64.subarray(pointer / bytesPerElement, pointer / bytesPerElement + capacity);
+    const wasmFloat64View = wasmHeapView(this.wasmModule, Float64Array, pointer, capacity);
     let offset = 0;
     let prevLocalID = -1;
     for (let i = 0; i < points.length; i++) {
@@ -92322,6 +92370,225 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
       model.nullOnErrors = priorNullOnErrors;
     }
   }
+  /**
+   * Reduce a grid axis to an unbounded line in the plane of the grid's
+   * placement: a point on it, and its tangent there.
+   *
+   * Only the straight axis curves are handled — an IfcLine, or the single
+   * segment of a two-point IfcPolyline — which is what grid axes are in
+   * practice. Anything else returns undefined after warning, so the
+   * placement lands in errors.csv rather than being dropped in silence.
+   *
+   * `SameSense` is folded into the tangent because everything downstream is
+   * measured from it: the offset in IfcVirtualGridIntersection is normal to
+   * the tangent, and the tangent is also an IfcGridPlacement's default
+   * x-axis, so a reversed axis offsets to the other side and points the
+   * other way.
+   *
+   * @param axis The grid axis to reduce.
+   * @return {{x, y, dx, dy} | undefined} A point and (unnormalised) tangent
+   * in the grid's coordinate system, or undefined for an axis curve this
+   * does not handle.
+   */
+  static gridAxisLine(axis) {
+    const curve = axis.AxisCurve;
+    let x;
+    let y;
+    let dx;
+    let dy;
+    if (curve instanceof IfcPolyline) {
+      const points = curve.Points;
+      if (points.length !== 2) {
+        logger_default.warning("IfcGridPlacement: grid axis IfcPolyline is not a single segment.", axis.expressID);
+        return void 0;
+      }
+      const start = points[0].Coordinates;
+      const end = points[1].Coordinates;
+      x = start[0];
+      y = start[1];
+      dx = end[0] - start[0];
+      dy = end[1] - start[1];
+    } else if (curve instanceof IfcLine) {
+      const origin = curve.Pnt.Coordinates;
+      const direction = curve.Dir.Orientation.DirectionRatios;
+      x = origin[0];
+      y = origin[1];
+      dx = direction[0];
+      dy = direction[1];
+    } else {
+      logger_default.warning(`IfcGridPlacement: unsupported grid axis curve, type: ${entity_types_ifc_gen_default[curve.type]}`, axis.expressID);
+      return void 0;
+    }
+    if (!axis.SameSense) {
+      dx = -dx;
+      dy = -dy;
+    }
+    return { x, y, dx, dy };
+  }
+  /**
+   * Resolve an IfcVirtualGridIntersection to a point in the coordinate system
+   * of the IfcGrid that owns its axes, along with the tangent of its first
+   * axis — which is the default x-axis of an IfcGridPlacement located here.
+   *
+   * Per IFC4 each axis is replaced by its offset curve before intersecting:
+   * OffsetDistances[n] is measured from axis n normal to its tangent,
+   * positive towards the tangent turned a quarter turn anti-clockwise. Both
+   * axes here are straight, so their offset curves are parallel to them and
+   * the tangents are unchanged. A third offset, when the file gives one,
+   * displaces the result along the grid placement's z axis.
+   *
+   * @param from The intersection to resolve.
+   * @return {{position, tangent} | undefined} The intersection point and the
+   * first axis' unit tangent, or undefined when the axes cannot be reduced to
+   * two lines that meet (warned at the point of failure).
+   */
+  resolveVirtualGridIntersection(from) {
+    const axes = from.IntersectingAxes;
+    if (axes.length < GRID_INTERSECTION_AXIS_COUNT) {
+      logger_default.warning("IfcGridPlacement: virtual grid intersection has fewer than two axes.", from.expressID);
+      return void 0;
+    }
+    const line0 = _IfcGeometryExtraction.gridAxisLine(axes[0]);
+    const line1 = _IfcGeometryExtraction.gridAxisLine(axes[1]);
+    if (line0 === void 0 || line1 === void 0) {
+      return void 0;
+    }
+    const length0 = Math.sqrt(line0.dx * line0.dx + line0.dy * line0.dy);
+    const length1 = Math.sqrt(line1.dx * line1.dx + line1.dy * line1.dy);
+    const cross = line0.dx * line1.dy - line0.dy * line1.dx;
+    if (Math.abs(cross) <= GRID_AXIS_PARALLEL_EPSILON * length0 * length1) {
+      logger_default.warning("IfcGridPlacement: intersecting grid axes are parallel or degenerate.", from.expressID);
+      return void 0;
+    }
+    const offsets = from.OffsetDistances;
+    const offset0 = offsets[0] ?? 0;
+    const offset1 = offsets[1] ?? 0;
+    const x0 = line0.x - offset0 * line0.dy / length0;
+    const y0 = line0.y + offset0 * line0.dx / length0;
+    const x1 = line1.x - offset1 * line1.dy / length1;
+    const y1 = line1.y + offset1 * line1.dx / length1;
+    const t = ((x1 - x0) * line1.dy - (y1 - y0) * line1.dx) / cross;
+    return {
+      position: {
+        x: x0 + t * line0.dx,
+        y: y0 + t * line0.dy,
+        z: offsets[GRID_INTERSECTION_Z_OFFSET] ?? 0
+      },
+      tangent: { x: line0.dx / length0, y: line0.dy / length0 }
+    };
+  }
+  /**
+   * The IfcGrid that lists a given axis, or undefined if no grid does.
+   *
+   * IfcGridAxis's route back to its grid is the PartOfU/PartOfV/PartOfW
+   * inverse attributes, and the generated schema layer carries no inverses,
+   * so this is a scan of every IfcGrid's axis lists, memoised. It is built on
+   * the first grid placement extracted and never at all for a model without
+   * one.
+   *
+   * @param axis The axis to look up.
+   * @return {IfcGrid | undefined} The grid listing the axis.
+   */
+  gridByAxis(axis) {
+    let gridByAxis = this.gridByAxis_;
+    if (gridByAxis === void 0) {
+      gridByAxis = /* @__PURE__ */ new Map();
+      for (const grid of this.model.types(IfcGrid)) {
+        for (const gridAxis of grid.UAxes) {
+          gridByAxis.set(gridAxis.localID, grid);
+        }
+        for (const gridAxis of grid.VAxes) {
+          gridByAxis.set(gridAxis.localID, grid);
+        }
+        for (const gridAxis of grid.WAxes ?? []) {
+          gridByAxis.set(gridAxis.localID, grid);
+        }
+      }
+      this.gridByAxis_ = gridByAxis;
+    }
+    return gridByAxis.get(axis.localID);
+  }
+  /**
+   * Extract an IfcGridPlacement, registering a transform against its local ID
+   * the same way the IfcLocalPlacement arm does — same scene, same
+   * memoisation, same composition onto the current parent.
+   *
+   * The origin is the virtual intersection of two grid axes and the x-axis
+   * comes from PlacementRefDirection (defaulting to the first axis' tangent),
+   * both expressed in the coordinate system of the IfcGrid that owns the
+   * axes. IfcGridPlacement has no PlacementRelTo of its own in IFC4, so that
+   * grid's object placement IS the parent: extracting it first leaves it as
+   * the scene's current transform, which `addTransform` then composes onto.
+   *
+   * @param from The grid placement to extract.
+   * @param isRelVoid Whether this placement is being resolved into the void
+   * scene rather than the main one.
+   */
+  extractGridPlacement(from, isRelVoid) {
+    const placementLocation = from.PlacementLocation;
+    const location = this.resolveVirtualGridIntersection(placementLocation);
+    if (location === void 0) {
+      return;
+    }
+    let xAxisRef = { x: location.tangent.x, y: location.tangent.y, z: 0 };
+    const refDirection = from.PlacementRefDirection;
+    if (refDirection instanceof IfcDirection) {
+      const ratios = refDirection.DirectionRatios;
+      xAxisRef = { x: ratios[0], y: ratios[1], z: ratios[2] ?? 0 };
+    } else if (refDirection instanceof IfcVirtualGridIntersection) {
+      const reference = this.resolveVirtualGridIntersection(refDirection);
+      if (reference !== void 0) {
+        xAxisRef = {
+          x: reference.position.x - location.position.x,
+          y: reference.position.y - location.position.y,
+          z: reference.position.z - location.position.z
+        };
+      }
+    }
+    const xAxisRefPlanar = Math.sqrt(xAxisRef.x * xAxisRef.x + xAxisRef.y * xAxisRef.y);
+    const xAxisRefLength = Math.sqrt(xAxisRefPlanar * xAxisRefPlanar + xAxisRef.z * xAxisRef.z);
+    if (xAxisRefPlanar <= GRID_AXIS_PARALLEL_EPSILON * xAxisRefLength) {
+      logger_default.warning("IfcGridPlacement: the placement reference direction is parallel to the grid placement's z axis, or has no length - falling back to the schema default, the first axis' tangent.", from.expressID);
+      xAxisRef = { x: location.tangent.x, y: location.tangent.y, z: 0 };
+    }
+    let grid;
+    let gridScanned = false;
+    try {
+      grid = this.gridByAxis(placementLocation.IntersectingAxes[0]);
+      gridScanned = true;
+    } catch (error) {
+      if (!(error instanceof StepBufferNotResidentError)) {
+        throw error;
+      }
+      logger_default.warning("IfcGridPlacement: grid records are not resident on this windowed source - placing at the grid intersection in the current frame, without the grid's own placement.", from.expressID);
+    }
+    if (gridScanned && grid === void 0) {
+      logger_default.warning("IfcGridPlacement: no IfcGrid lists the axes of this placement.", from.expressID);
+    } else if (grid !== void 0) {
+      try {
+        const gridPlacement = grid.ObjectPlacement;
+        if (gridPlacement !== null) {
+          this.extractPlacement(gridPlacement, isRelVoid);
+        }
+      } catch (error) {
+        if (!(error instanceof StepBufferNotResidentError)) {
+          throw error;
+        }
+        logger_default.warning("IfcGridPlacement: the grid's own placement chain is not fully resident on this windowed source - it was applied as far as it reads, so this placement composes onto a partial frame.", from.expressID);
+      }
+    }
+    const placementTransform = this.conwayModel.getAxis2Placement3D({
+      position: location.position,
+      // A grid is planar in its own placement, so this placement's z axis is
+      // the grid's z axis; only the x axis is steered here.
+      zAxisRef: { x: 0, y: 0, z: 1 },
+      xAxisRef,
+      normalizeZ: false,
+      normalizeX: true
+    });
+    const scene = isRelVoid ? this.voidScene : this.scene;
+    scene.addTransform(from.localID, placementTransform.getValues(), placementTransform);
+  }
   /**
    *
    * @param from
@@ -92356,6 +92623,7 @@ var IfcGeometryExtraction = class _IfcGeometryExtraction {
         }
       }
     } else if (from instanceof IfcGridPlacement) {
+      this.extractGridPlacement(from, isRelVoid);
     }
   }
   /**