@bldrs-ai/conway 1.578.1546 → 1.579.1547

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.578.1546";
+var versionString = "Conway v1.579.1547";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

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.578.1546";
+var versionString = "Conway v1.579.1547";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.578.1546";
+var versionString = "Conway v1.579.1547";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {
@@ -82528,6 +82528,9 @@ var AP214SceneBuilder = class {
 // compiled/src/AP214E3_2010/ap214_geometry_extraction.js
 var MINIMUM_BOUND_POINTS = 3;
 var MAXIMUM_PCURVE_SPAN_SAMPLES = 256;
+var AP214_ITEMS_PER_DEMAND_UNIT = 4;
+var AP214_MAX_ITEM_UNITS_PER_REPRESENTATION = 256;
+var AP214_MAX_REPLAYED_PLACEMENTS = 8;
 function isWholeCurveEdge(basisCurve, edgeStart, edgeEnd) {
   if (!(edgeStart instanceof vertex_point) || !(edgeEnd instanceof vertex_point)) {
     return false;
@@ -82586,6 +82589,7 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
     this.csgDepth = 0;
     this.freeVectorPolygonalFaces_ = [];
     this.geometryTypeCounts = /* @__PURE__ */ new Map();
+    this.demandItemsPerUnit = AP214_ITEMS_PER_DEMAND_UNIT;
     this.demandCursor_ = 0;
     this.csgMemoization = !this.lowMemoryMode;
     this.quietRecoverableLogging = false;
@@ -84208,31 +84212,14 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
       this.scene.addTransform(from.localID, nativeTransform.getValues(), nativeTransform, true);
       ++pushedTransforms;
     };
-    if (mappingTarget instanceof cartesian_transformation_operator_3d) {
-      const nativeCartesianTransform = this.extractCartesianTransformOperator3D(mappingTarget);
-      const originTransform = mappingOrigin instanceof placement ? this.extractRawPlacement(mappingOrigin) : void 0;
-      let combinedTransform;
-      if (originTransform !== void 0) {
-        const from2 = originTransform.invert();
-        const to = nativeCartesianTransform;
-        const params = {
-          useRelPlacement: true,
-          axis2Placement: from2,
-          relPlacement: to
-        };
-        combinedTransform = this.conwayModel.getLocalPlacement(params);
-      } else {
-        combinedTransform = nativeCartesianTransform;
-      }
-      pushTransform(combinedTransform);
-    } else if (mappingTarget instanceof placement) {
-      const targetTransform = this.extractRawPlacement(mappingTarget);
-      const originTransform = mappingOrigin instanceof placement ? this.extractRawPlacement(mappingOrigin) : void 0;
-      if (targetTransform !== void 0) {
+    try {
+      if (mappingTarget instanceof cartesian_transformation_operator_3d) {
+        const nativeCartesianTransform = this.extractCartesianTransformOperator3D(mappingTarget);
+        const originTransform = mappingOrigin instanceof placement ? this.extractRawPlacement(mappingOrigin) : void 0;
         let combinedTransform;
         if (originTransform !== void 0) {
           const from2 = originTransform.invert();
-          const to = targetTransform;
+          const to = nativeCartesianTransform;
           const params = {
             useRelPlacement: true,
             axis2Placement: from2,
@@ -84240,44 +84227,64 @@ var AP214GeometryExtraction = class _AP214GeometryExtraction {
           };
           combinedTransform = this.conwayModel.getLocalPlacement(params);
         } else {
-          combinedTransform = targetTransform;
+          combinedTransform = nativeCartesianTransform;
         }
         pushTransform(combinedTransform);
+      } else if (mappingTarget instanceof placement) {
+        const targetTransform = this.extractRawPlacement(mappingTarget);
+        const originTransform = mappingOrigin instanceof placement ? this.extractRawPlacement(mappingOrigin) : void 0;
+        if (targetTransform !== void 0) {
+          let combinedTransform;
+          if (originTransform !== void 0) {
+            const from2 = originTransform.invert();
+            const to = targetTransform;
+            const params = {
+              useRelPlacement: true,
+              axis2Placement: from2,
+              relPlacement: to
+            };
+            combinedTransform = this.conwayModel.getLocalPlacement(params);
+          } else {
+            combinedTransform = targetTransform;
+          }
+          pushTransform(combinedTransform);
+        }
       }
-    }
-    for (const representationItem of representationMap.mapped_representation.items) {
-      if (representationItem instanceof mapped_item) {
-        this.extractMappedItem(representationItem, owningElementLocalID, parents !== void 0 ? [from, ...parents] : [from]);
-      } else {
-        this.extractRepresentationItem(representationItem, owningElementLocalID);
-        const styledItemLocalID_ = this.materials.styledItemMap.get(representationItem.localID);
-        let materialOverrideID = void 0;
-        if (styledItemLocalID_ !== void 0) {
-          const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
-          this.extractStyledItem(styledItem_);
+      for (const representationItem of representationMap.mapped_representation.items) {
+        if (representationItem instanceof mapped_item) {
+          this.extractMappedItem(representationItem, owningElementLocalID, parents !== void 0 ? [from, ...parents] : [from]);
         } else {
-          let styledItemParentLocalID = this.materials.styledItemMap.get(from.localID);
-          let styleParent = from;
-          if (parents !== void 0) {
-            for (const parent of parents) {
-              if (styledItemParentLocalID !== void 0) {
-                break;
+          this.extractRepresentationItem(representationItem, owningElementLocalID);
+          const styledItemLocalID_ = this.materials.styledItemMap.get(representationItem.localID);
+          let materialOverrideID = void 0;
+          if (styledItemLocalID_ !== void 0) {
+            const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
+            this.extractStyledItem(styledItem_);
+          } else {
+            let styledItemParentLocalID = this.materials.styledItemMap.get(from.localID);
+            let styleParent = from;
+            if (parents !== void 0) {
+              for (const parent of parents) {
+                if (styledItemParentLocalID !== void 0) {
+                  break;
+                }
+                styledItemParentLocalID = this.materials.styledItemMap.get(parent.localID);
+                styleParent = parent;
               }
-              styledItemParentLocalID = this.materials.styledItemMap.get(parent.localID);
-              styleParent = parent;
+            }
+            if (styledItemParentLocalID !== void 0) {
+              const styledItemParent = this.model.getElementByLocalID(styledItemParentLocalID);
+              this.extractStyledItem(styledItemParent, representationItem);
+              materialOverrideID = styleParent.localID;
             }
           }
-          if (styledItemParentLocalID !== void 0) {
-            const styledItemParent = this.model.getElementByLocalID(styledItemParentLocalID);
-            this.extractStyledItem(styledItemParent, representationItem);
-            materialOverrideID = styleParent.localID;
-          }
+          this.scene.addGeometry(representationItem.localID, owningElementLocalID, materialOverrideID);
         }
-        this.scene.addGeometry(representationItem.localID, owningElementLocalID, materialOverrideID);
       }
-    }
-    for (; pushedTransforms > 0; --pushedTransforms) {
-      this.scene.popTransform();
+    } finally {
+      for (; pushedTransforms > 0; --pushedTransforms) {
+        this.scene.popTransform();
+      }
     }
   }
   /**
@@ -85430,14 +85437,18 @@ ${error.stack} - expressID: #${face_.expressID}`);
    * Prepare per-unit demand extraction (STEP demand parity phase 2)
    * without executing any geometry work: builds the assembly tree and
    * thunks exactly like the whole-model walk, but the root executions
-   * are captured as an ordered list of UNITS — a childless root is one
-   * unit; a root with children is flattened one level (one unit per
-   * immediate child, in order, then one for the root's own items), so
-   * single-root assemblies still pump progressively per part. Executing
-   * every unit in order then calling {@link finishDemandExtraction}
-   * reproduces the whole-model walk exactly — the classic
-   * {@link extractAP214GeometryData} runs through this same path.
-   * Idempotent.
+   * are captured as an ordered list of UNITS. The tree is flattened
+   * DEPTH FIRST — one unit per child (descending into any child whose
+   * subtree carries more than {@link AP214_ITEMS_PER_DEMAND_UNIT}
+   * items), then one unit per range of a node's own representation
+   * items — so a single-root assembly pumps progressively all the way
+   * down to individual solids rather than per top-level part
+   * (conway#579: Arty's silkscreen is 654 solids sitting two levels
+   * under the only root, which used to make it one 22 s task).
+   * Executing every unit in order then calling
+   * {@link finishDemandExtraction} reproduces the whole-model walk
+   * exactly — the classic {@link extractAP214GeometryData} runs through
+   * this same path. Idempotent.
    */
   // eslint-disable-next-line max-lines-per-function
   prepareDemandExtraction() {
@@ -85471,7 +85482,8 @@ ${error.stack} - expressID: #${face_.expressID}`);
             occurrenceExpressID ??= this.model.getExpressIDByLocalID(childOwningLocalID);
             this.scene.pushOccurrence(occurrenceExpressID ?? childOwningLocalID);
             try {
-              mappedChild.thunk(childOwningLocalID, childTransform);
+              const runChild = slice?.childThunk ?? mappedChild.thunk;
+              runChild(childOwningLocalID, childTransform);
             } catch (ex) {
               if (this.quietRecoverableLogging) {
               } else if (ex instanceof Error) {
@@ -85493,7 +85505,22 @@ ${error.stack} - expressID: #${face_.expressID}`);
           }
         }
         const includeItems = slice?.includeItems ?? true;
-        for (const item of includeItems ? representation2.items : []) {
+        const items = includeItems ? representation2.items : [];
+        const itemStart = slice?.itemStart ?? 0;
+        const itemEnd = Math.min(slice?.itemEnd ?? items.length, items.length);
+        for (const replayIndex of slice?.replayPlacements ?? []) {
+          const replayItem = items[replayIndex];
+          if (replayItem instanceof placement) {
+            try {
+              this.extractPlacement(replayItem, mappedItem);
+            } catch {
+            }
+          }
+        }
+        const verifySliceNeutrality = slice?.itemStart !== void 0;
+        for (let itemIndex = itemStart; itemIndex < itemEnd; ++itemIndex) {
+          const item = items[itemIndex];
+          const depthBeforeItem = verifySliceNeutrality ? this.scene.stackLength : 0;
           try {
             if (item instanceof placement) {
               this.extractPlacement(item, mappedItem);
@@ -85523,6 +85550,10 @@ ${error.stack} - expressID: #${face_.expressID}`);
             } else {
               logger_default.error(`Unknown exception processing representation item (${ex}) expressID: #${item.expressID}`);
             }
+          } finally {
+            if (verifySliceNeutrality && !(item instanceof placement) && this.scene.stackLength !== depthBeforeItem && !this.quietRecoverableLogging) {
+              logger_default.error(`Representation item left transform state inside a sliced range expressID: #${item.expressID}`);
+            }
           }
         }
         while (this.scene.stackLength > entryTransformDepth) {
@@ -85533,6 +85564,51 @@ ${error.stack} - expressID: #${face_.expressID}`);
         }
       };
     };
+    const itemUnitRanges = (representation2) => {
+      let items;
+      try {
+        items = representation2.items;
+      } catch {
+        return void 0;
+      }
+      const itemCount = items.length;
+      if (itemCount <= this.demandItemsPerUnit) {
+        return void 0;
+      }
+      const itemsPerUnit = Math.max(this.demandItemsPerUnit, Math.ceil(itemCount / AP214_MAX_ITEM_UNITS_PER_REPRESENTATION));
+      const ranges = [];
+      const replayed = [];
+      const pending = [];
+      let start = 0;
+      for (let cursor = 0; cursor < itemCount; ++cursor) {
+        if (items[cursor] instanceof placement) {
+          pending.push(cursor);
+        }
+        if (cursor + 1 - start < itemsPerUnit || cursor + 1 >= itemCount) {
+          continue;
+        }
+        if (replayed.length + pending.length > AP214_MAX_REPLAYED_PLACEMENTS) {
+          break;
+        }
+        ranges.push({
+          itemStart: start,
+          itemEnd: cursor + 1,
+          replayPlacements: replayed.length > 0 ? replayed.slice() : void 0
+        });
+        replayed.push(...pending);
+        pending.length = 0;
+        start = cursor + 1;
+      }
+      if (ranges.length === 0) {
+        return void 0;
+      }
+      ranges.push({
+        itemStart: start,
+        itemEnd: itemCount,
+        replayPlacements: replayed.length > 0 ? replayed.slice() : void 0
+      });
+      return ranges;
+    };
     const pendingRoots = [];
     {
       this.scene.clearParentStack();
@@ -85737,20 +85813,80 @@ ${error.stack} - expressID: #${face_.expressID}`);
         }
       }
       const units = [];
+      const subtreeItemCounts = /* @__PURE__ */ new Map();
+      const ownItemCount = (node) => {
+        if (node.rep === void 0) {
+          return 0;
+        }
+        try {
+          return node.rep.items.length;
+        } catch {
+          return 0;
+        }
+      };
+      const subtreeItemCount = (node, path3) => {
+        const memoized = subtreeItemCounts.get(node);
+        if (memoized !== void 0) {
+          return memoized;
+        }
+        if (path3.has(node)) {
+          return 0;
+        }
+        path3.add(node);
+        let count = ownItemCount(node);
+        for (const [childLocalID] of node.children ?? []) {
+          const child = treeMap.get(childLocalID);
+          if (child !== void 0) {
+            count += subtreeItemCount(child, path3);
+          }
+        }
+        path3.delete(node);
+        subtreeItemCounts.set(node, count);
+        return count;
+      };
+      const expandUnits = (node, path3, wrap) => {
+        const childCount = node.children?.length ?? 0;
+        for (let child = 0; child < childCount; ++child) {
+          const childNode = treeMap.get(node.children[child][0]);
+          const descend = childNode !== void 0 && childNode.rep !== void 0 && childNode.thunk !== void 0 && !path3.has(childNode) && subtreeItemCount(childNode, /* @__PURE__ */ new Set()) > this.demandItemsPerUnit;
+          if (!descend) {
+            wrap({ childStart: child, childEnd: child + 1, includeItems: false });
+            continue;
+          }
+          const descendant = childNode;
+          path3.add(descendant);
+          expandUnits(descendant, path3, (childSlice) => {
+            const childThunk = makeThunk(descendant.rep, descendant.owningLocalID, descendant, childSlice);
+            wrap({
+              childStart: child,
+              childEnd: child + 1,
+              includeItems: false,
+              childThunk
+            });
+          });
+          path3.delete(descendant);
+        }
+        const itemRanges = node.rep !== void 0 ? itemUnitRanges(node.rep) : void 0;
+        if (itemRanges === void 0) {
+          wrap({ childStart: 0, childEnd: 0, includeItems: true });
+          return;
+        }
+        for (const range of itemRanges) {
+          wrap({ childStart: 0, childEnd: 0, includeItems: true, ...range });
+        }
+      };
       for (const root of pendingRoots) {
         const node = root.node;
         const scaleTransform = root.scaleTransform;
-        const childCount = node.children?.length ?? 0;
-        if (childCount === 0 || node.rep === void 0) {
+        const rep = node.rep;
+        if (rep === void 0) {
           units.push(() => node.thunk(void 0, scaleTransform));
           continue;
         }
-        for (let child = 0; child < childCount; ++child) {
-          const sliced = makeThunk(node.rep, node.owningLocalID, node, { childStart: child, childEnd: child + 1, includeItems: false });
+        expandUnits(node, /* @__PURE__ */ new Set([node]), (slice) => {
+          const sliced = makeThunk(rep, node.owningLocalID, node, slice);
           units.push(() => sliced(void 0, scaleTransform));
-        }
-        const itemsOnly = makeThunk(node.rep, node.owningLocalID, node, { childStart: 0, childEnd: 0, includeItems: true });
-        units.push(() => itemsOnly(void 0, scaleTransform));
+        });
       }
       this.demandUnits_ = units;
     }
@@ -85791,15 +85927,32 @@ ${error.stack} - expressID: #${face_.expressID}`);
    * AP214 models. Staged face tessellation is finalized after every
    * batch so captured geometry is complete and readable.
    *
+   * `budgetMs` is what keeps an interactive caller's thread responsive
+   * now that a unit is a slice rather than a product. Unit cost is wildly
+   * uneven both across models and inside one: Arty_Z7's 603 units average
+   * 58 ms but run from under a millisecond to 600 ms (a single silkscreen
+   * solid), while DSA2's average 32 ms. No fixed unit-count-per-call
+   * serves that — it either overshoots the frame budget on the expensive
+   * units or burns hundreds of calls on the cheap ones — so a caller with
+   * a frame to hit passes a wall-clock budget and gets as many units as
+   * fit. One unit always runs: a single unit that overruns the budget is
+   * the floor this layer can offer, and shrinking it further is geometry
+   * cost, not granularity (conway#564). Callers that want completion
+   * rather than responsiveness (the whole-model walk, the deferred drain)
+   * pass no budget and keep the pre-conway#579 behaviour exactly.
+   *
    * @param count Max units to execute this call (min 1).
+   * @param budgetMs Wall-clock this call may spend before returning
+   * early; unbounded when absent.
    * @return {number} Units actually executed.
    */
-  extractDemandUnitBatch(count) {
+  extractDemandUnitBatch(count, budgetMs) {
     const units = this.demandUnits_;
     if (units === void 0) {
       return 0;
     }
     const end = Math.min(this.demandCursor_ + Math.max(count, 1), units.length);
+    const deadline = budgetMs !== void 0 ? Date.now() + budgetMs : void 0;
     let executed = 0;
     for (; this.demandCursor_ < end; ++this.demandCursor_) {
       try {
@@ -85815,6 +85968,15 @@ ${error.stack} - expressID: #${face_.expressID}`);
           logger_default.error(`Unknown exception processing demand unit (${ex})`);
         }
       }
+      if (deadline !== void 0) {
+        if (this.useStagedFaces) {
+          this.finalizeStagedFaces();
+        }
+        if (Date.now() >= deadline) {
+          ++this.demandCursor_;
+          break;
+        }
+      }
     }
     this.finalizeStagedFaces();
     return executed;

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.578.1546";
+var versionString = "Conway v1.579.1547";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/AP214E3_2010/ap214_demand_unit_slicing.test.d.ts

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

package/compiled/src/AP214E3_2010/ap214_demand_unit_slicing.test.d.ts.map

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

package/compiled/src/AP214E3_2010/ap214_demand_unit_slicing.test.js

@@ -0,0 +1,170 @@
+import fs from "fs";
+import { describe, expect, test, beforeAll } from "@jest/globals";
+import { AP214GeometryExtraction } from "./ap214_geometry_extraction.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import AP214StepParser from "./ap214_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { ExtractResult } from "../core/shared_constants.js";
+/**
+ * conway#579: a demand unit used to be a whole product, so one item-heavy
+ * representation (Arty_Z7's silkscreen: 654 solids in one
+ * ADVANCED_BREP_SHAPE_REPRESENTATION, two levels under the only root) ran
+ * as a single 22 s uninterruptible task. prepareDemandExtraction now
+ * flattens depth first and cuts a representation's `items` into index
+ * ranges, which is only sound if the cut walk visits the same items in the
+ * same order with the same transform state — the claim these tests pin.
+ *
+ * `demandItemsPerUnit` is the granularity knob: `Infinity` reproduces the
+ * pre-change flattening (one unit per immediate child of a root, plus one
+ * for the root's own items), and small values cut both deeper and finer.
+ * Every setting has to emit byte-identical placed geometry.
+ */
+/** Assembly with a 13-NAUO occurrence tree and real BREP leaves. */
+const ASSEMBLY_FIXTURE = "data/as1-oc-214.stp";
+/**
+ * Single-root assembly whose #14069 ADVANCED_BREP_SHAPE_REPRESENTATION
+ * carries ten solids in one `items` array — the multi-item representation
+ * the issue is about, at a size the default granularity actually cuts.
+ */
+const MULTI_ITEM_FIXTURE = "data/nema-23-76mm.step";
+/**
+ * Derived from `create-a-tube.step`: one
+ * ADVANCED_BREP_SHAPE_REPRESENTATION holding a NON-IDENTITY
+ * AXIS2_PLACEMENT_3D followed by three copies of the tube solid. That
+ * leading placement is the state the item loop carries — it pushes onto
+ * the scene transform stack and places every item after it — so a range
+ * that starts past it lands its solids at the wrong place unless the
+ * range replays it. It is also the shape of the worst real case:
+ * DSA2.step's single root is one placement followed by 28,674 solids.
+ */
+const LEADING_PLACEMENT_FIXTURE = "data/ap214-sliced-item-ranges.step";
+/**
+ * Six items, the first of which is a MAPPED_ITEM that pushes its mapping
+ * transform and then throws (its REPRESENTATION_MAP's
+ * `mapped_representation` points at a CARTESIAN_POINT, so the dereference
+ * fails after the push).
+ *
+ * That failure path is the one way a NON-placement item can leave
+ * transform state behind: extractMappedItem's pop loop is unreachable once
+ * the walk between the pushes throws. Unsliced, the leak displaces every
+ * later item in the representation; sliced, only the ones sharing its
+ * range — so the geometry depended on where the cut fell until
+ * extractMappedItem was made to pop in a `finally`. No model in the
+ * regression corpus contains a MAPPED_ITEM at all, so this fixture is the
+ * only thing standing between that fix and a silent regression.
+ */
+const MAPPED_ITEM_FAILURE_FIXTURE = "data/ap214-mapped-item-failure.step";
+/* Wasm init, and the per-test budgets: these extractions run real BREPs. */
+const WASM_INIT_TIMEOUT_MS = 60000;
+const EXTRACT_TIMEOUT_MS = 120000;
+const MULTI_EXTRACT_TIMEOUT_MS = 300000;
+// Column-major 4x4: the translation column sits at 12, 13, 14.
+const TRANSLATION_START = 12;
+const TRANSLATION_END = 15;
+let conwayGeometry;
+beforeAll(async () => {
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+}, WASM_INIT_TIMEOUT_MS);
+/**
+ * Extract the fixture at one granularity and reduce the resulting scene to
+ * a comparable digest of every placed geometry instance, in walk order.
+ *
+ * The model is re-parsed per call because extraction memoizes geometry into
+ * it — two granularities have to start from equally cold models or the
+ * second one measures the first one's cache.
+ *
+ * @param fixture Path to the STEP file.
+ * @param itemsPerUnit Value for `demandItemsPerUnit`.
+ * @return {[PlacedDigest[], number]} The digest and the unit count.
+ */
+function extractAt(fixture, itemsPerUnit) {
+    const parser = AP214StepParser.Instance;
+    const buffer = new ParsingBuffer(fs.readFileSync(fixture));
+    expect(parser.parseHeader(buffer)[1]).toBe(ParseResult.COMPLETE);
+    const [, model] = parser.parseDataToModel(buffer);
+    expect(model).not.toBe(void 0);
+    const extraction = new AP214GeometryExtraction(conwayGeometry, model);
+    extraction.demandItemsPerUnit = itemsPerUnit;
+    extraction.prepareDemandExtraction();
+    const unitCount = extraction.demandUnitCount;
+    const [result, scene] = extraction.extractAP214GeometryData();
+    expect(result).toBe(ExtractResult.COMPLETE);
+    return [placedDigest(scene), unitCount];
+}
+/**
+ * Reduce a scene to one row per placed geometry instance: what it is, where
+ * the walk put it, and the contents of its vertex and index buffers.
+ *
+ * @param scene The extracted scene.
+ * @return {PlacedDigest[]} One row per instance, in walk order.
+ */
+function placedDigest(scene) {
+    const wasm = conwayGeometry.wasmModule;
+    const rows = [];
+    for (const [transform, , mesh, , entity, occurrencePath] of scene.walkWithOccurrence()) {
+        const geometry = mesh.geometry;
+        if (geometry === void 0 || typeof geometry.GetVertexDataSize !== "function") {
+            continue;
+        }
+        // Read into copies immediately — HEAPF32/HEAPU32 views detach on wasm
+        // memory growth and a held view silently reads zeroes.
+        const floatCount = geometry.GetVertexDataSize();
+        const vertexData = wasm.HEAPF32.slice(geometry.GetVertexData() / 4, (geometry.GetVertexData() / 4) + floatCount);
+        const indexCount = geometry.GetIndexDataSize();
+        const indexData = wasm.HEAPU32.slice(geometry.GetIndexData() / 4, (geometry.GetIndexData() / 4) + indexCount);
+        rows.push({
+            expressID: entity?.expressID,
+            occurrencePath: occurrencePath.join("/"),
+            transform: (transform ?? []).join(","),
+            vertices: `${floatCount}:${vertexData.join(",")}`,
+            indices: `${indexCount}:${indexData.join(",")}`,
+        });
+    }
+    return rows;
+}
+describe("AP214 demand unit granularity (conway#579)", () => {
+    test("an assembly extracts identically sliced and unsliced", () => {
+        const [unsliced, unslicedUnits] = extractAt(ASSEMBLY_FIXTURE, Infinity);
+        const [sliced, slicedUnits] = extractAt(ASSEMBLY_FIXTURE, 1);
+        // Without this the equality below would hold trivially.
+        expect(slicedUnits).toBeGreaterThan(unslicedUnits);
+        expect(unsliced.length).toBeGreaterThan(0);
+        expect(sliced).toStrictEqual(unsliced);
+    }, EXTRACT_TIMEOUT_MS);
+    test("a ten-solid representation extracts identically at every granularity", () => {
+        const [unsliced, unslicedUnits] = extractAt(MULTI_ITEM_FIXTURE, Infinity);
+        const [atDefault, defaultUnits] = extractAt(MULTI_ITEM_FIXTURE, 4);
+        const [perItem, perItemUnits] = extractAt(MULTI_ITEM_FIXTURE, 1);
+        expect(defaultUnits).toBeGreaterThan(unslicedUnits);
+        expect(perItemUnits).toBeGreaterThan(defaultUnits);
+        expect(unsliced.length).toBeGreaterThan(0);
+        expect(atDefault).toStrictEqual(unsliced);
+        expect(perItem).toStrictEqual(unsliced);
+    }, MULTI_EXTRACT_TIMEOUT_MS);
+    test("ranges after a leading placement are still placed by it", () => {
+        const [unsliced, unslicedUnits] = extractAt(LEADING_PLACEMENT_FIXTURE, Infinity);
+        const [sliced, slicedUnits] = extractAt(LEADING_PLACEMENT_FIXTURE, 1);
+        expect(slicedUnits).toBeGreaterThan(unslicedUnits);
+        // Three solids, and the placement they inherit is not the identity —
+        // both of which have to hold or the equality below proves nothing.
+        expect(unsliced.length).toBe(3);
+        expect(unsliced[0].transform).not.toBe("");
+        expect(unsliced[0].transform.split(",").slice(TRANSLATION_START, TRANSLATION_END))
+            .not.toStrictEqual(["0", "0", "0"]);
+        expect(sliced).toStrictEqual(unsliced);
+    }, EXTRACT_TIMEOUT_MS);
+    test("a mapped item that throws after pushing does not shift later items", () => {
+        const [unsliced, unslicedUnits] = extractAt(MAPPED_ITEM_FAILURE_FIXTURE, Infinity);
+        const [atDefault, defaultUnits] = extractAt(MAPPED_ITEM_FAILURE_FIXTURE, 4);
+        const [perItem, perItemUnits] = extractAt(MAPPED_ITEM_FAILURE_FIXTURE, 1);
+        expect(defaultUnits).toBeGreaterThan(unslicedUnits);
+        expect(perItemUnits).toBeGreaterThan(defaultUnits);
+        // Five solids follow the failing mapped item; if the fixture ever stops
+        // producing them the equalities below stop meaning anything.
+        expect(unsliced.length).toBe(5);
+        expect(atDefault).toStrictEqual(unsliced);
+        expect(perItem).toStrictEqual(unsliced);
+    }, EXTRACT_TIMEOUT_MS);
+});