@bldrs-ai/conway 1.374.1181 → 1.376.1184

package/compiled/examples/browser-bundled.cjs

@@ -70042,7 +70042,7 @@ IfcStepParser.Instance = new IfcStepParser();
 var ifc_step_parser_default = IfcStepParser;
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.374.1181";
+var versionString = "Conway Web-Ifc Shim v1.376.1184";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

package/compiled/examples/cli-bundled.cjs

@@ -86283,7 +86283,7 @@ var IfcSceneBuilder = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.374.1181";
+var versionString = "Conway Web-Ifc Shim v1.376.1184";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

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

@@ -79734,7 +79734,7 @@ var ExtractResult;
 })(ExtractResult || (ExtractResult = {}));
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.374.1181";
+var versionString = "Conway Web-Ifc Shim v1.376.1184";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

package/compiled/examples/validator-bundled.cjs

@@ -70040,7 +70040,7 @@ IfcStepParser.Instance = new IfcStepParser();
 var ifc_step_parser_default = IfcStepParser;
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.374.1181";
+var versionString = "Conway Web-Ifc Shim v1.376.1184";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

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

@@ -23,7 +23,10 @@ export interface ProductStructureNode {
      * `product_definition` express id.
      */
     expressID: number;
-    /** Readable node kind: `'product'` for roots, `'product_occurrence'` for NAUO nodes. */
+    /**
+     * Readable node kind: `'product'` for roots, `'product_occurrence'` for NAUO
+     * nodes, `'solid'` for ephemeral sub-product solid nodes.
+     */
     type: string;
     /** Display label: `product.name`, falling back to the NAUO name / reference designator. */
     name: string;
@@ -43,9 +46,54 @@ export interface ProductStructureNode {
      * scene geometry for NavTree-click ⇄ viewport-pick round-tripping.
      */
     shapeRepresentationIds: number[];
-    /** Child occurrence nodes. */
+    /** Child occurrence nodes (and, when opted in, ephemeral solid nodes). */
     children: ProductStructureNode[];
+    /**
+     * True for ephemeral (non-product) nodes — pickable geometry that carries
+     * identity in the file but has no product semantics, e.g. one named solid of
+     * a multibody part. Consumers should render these lighter-weight,
+     * selectable-but-not-product. See `design/new/step-nonproduct-semantics.md`.
+     */
+    ephemeral?: boolean;
+    /**
+     * Number of this node's solids suppressed by the ephemeral-layer limits
+     * (unnamed-soup suppression or the per-product cap), so a consumer can
+     * render an "N more…" affordance instead of silently truncating.
+     */
+    droppedSolids?: number;
 }
+/**
+ * Options for {@link AP214ProductStructureExtraction.extractProductStructure}.
+ */
+export interface ProductStructureOptions {
+    /**
+     * Surface an ephemeral layer of solid-level nodes beneath each multibody
+     * product (default false). A product only gets solid children when its shape
+     * representation holds at least two solids — a single-solid product already
+     * maps 1:1 onto its node — and an all-unnamed set larger than
+     * {@link maxUnnamedSolidsPerProduct} is suppressed as meaningless "solid
+     * soup" (the DSA2 case: 28k unnamed single-face shells under one product).
+     */
+    includeSolids?: boolean;
+    /**
+     * Hard cap on emitted solid children per product occurrence
+     * (default {@link DEFAULT_MAX_SOLIDS_PER_PRODUCT}); overflow is reported via
+     * {@link ProductStructureNode.droppedSolids}.
+     */
+    maxSolidsPerProduct?: number;
+    /**
+     * When a product's solids are *all* unnamed and outnumber this (default
+     * {@link DEFAULT_MAX_UNNAMED_SOLIDS_PER_PRODUCT}), emit none of them:
+     * large anonymous solid dumps (ECAD merged-component products, tessellated
+     * surface soup) carry no navigable semantics. Named solids are never
+     * suppressed by this limit.
+     */
+    maxUnnamedSolidsPerProduct?: number;
+}
+/** Default hard cap on emitted solid children per product occurrence. */
+export declare const DEFAULT_MAX_SOLIDS_PER_PRODUCT = 256;
+/** Default suppression threshold for a product whose solids are all unnamed. */
+export declare const DEFAULT_MAX_UNNAMED_SOLIDS_PER_PRODUCT = 32;
 /**
  * Extracts the STEP product / assembly structure from a populated
  * {@link AP214StepModel} into a nested, named, occurrence-keyed tree.
@@ -63,6 +111,11 @@ export declare class AP214ProductStructureExtraction {
     private readonly childProductDefIds_;
     private readonly productDefById_;
     private readonly shapeRepsByProductDef_;
+    private readonly solidsByProductDef_;
+    private readonly solidIdsByProductDef_;
+    private includeSolids_;
+    private maxSolidsPerProduct_;
+    private maxUnnamedSolidsPerProduct_;
     /**
      * @param model The populated AP214/AP242 step model to walk.
      * @param productShapeMap Optional product↔shape map populated during geometry
@@ -75,11 +128,14 @@ export declare class AP214ProductStructureExtraction {
     /**
      * Build the product-structure tree.
      *
+     * @param options Optional {@link ProductStructureOptions}; pass
+     * `{ includeSolids: true }` to add the ephemeral solid layer beneath
+     * multibody products.
      * @return {ProductStructureNode[]} The roots of the assembly forest. A
      * single-part file yields one root; a multi-level assembly (e.g. `as1`) yields
      * one root whose descendants are the NAUO occurrences.
      */
-    extractProductStructure(): ProductStructureNode[];
+    extractProductStructure(options?: ProductStructureOptions): ProductStructureNode[];
     /**
      * Index every `product_definition` by express id for O(1) lookup during the
      * recursive walk.
@@ -98,6 +154,26 @@ export declare class AP214ProductStructureExtraction {
      * geometry-extraction product↔shape map.
      */
     private indexShapeRepresentations;
+    /**
+     * Index the solid-level bodies of each product definition for the ephemeral
+     * layer: walk each `shape_definition_representation`'s representation, plus
+     * any representation reachable over a *plain* `shape_representation_relationship`
+     * (SolidWorks binds a part's multibody `advanced_brep_shape_representation`
+     * to its SDR-bound representation that way — the NEMA motor pattern), and
+     * collect the solid items. Transformation-bearing relationship variants are
+     * assembly placements (parent rep ↔ child rep), so following them would leak
+     * every child part's solids into its parent assembly; they are skipped.
+     */
+    private indexSolids;
+    /**
+     * Record a solid for a product definition, de-duplicating by the solid's
+     * express id (a body can be reachable both directly and over a
+     * representation relationship).
+     *
+     * @param productDefId The owning product definition express id.
+     * @param solid The solid to record.
+     */
+    private addSolid;
     /**
      * Record a shape-representation id for a product definition, de-duplicating.
      *
@@ -118,6 +194,16 @@ export declare class AP214ProductStructureExtraction {
      * @return {ProductStructureNode} The built node, with children.
      */
     private buildNode;
+    /**
+     * Append this node's ephemeral solid children, applying the layer's
+     * heuristics (see {@link ProductStructureOptions}): nothing for a
+     * single-solid product, full suppression for oversized all-unnamed sets,
+     * and the hard per-product cap — suppressed/overflow counts are surfaced
+     * via {@link ProductStructureNode.droppedSolids}.
+     *
+     * @param node The product/occurrence node to attach solid children to.
+     */
+    private appendSolidChildren;
     /**
      * Resolve a node label, preferring the product name, then the occurrence's
      * own name / reference designator.

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

@@ -1 +1 @@
-{"version":3,"file":"ap214_product_structure_extraction.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_product_structure_extraction.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAOhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IAEnC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAA;IAEZ,2FAA2F;IAC3F,IAAI,EAAE,MAAM,CAAA;IAEZ,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAA;IAElC,mEAAmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B;;;;OAIG;IACH,cAAc,EAAE,MAAM,EAAE,CAAA;IAExB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAEhC,8BAA8B;IAC9B,QAAQ,EAAE,oBAAoB,EAAE,CAAA;CACjC;AAMD;;;;;;;;;GASG;AACH,qBAAa,+BAA+B;IAgBtC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;IAfrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsD;IACrF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAoB;IACxD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwC;IACxE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA8B;IAErE;;;;;;;OAOG;gBAEkB,KAAK,EAAE,cAAc,EACrB,eAAe,CAAC,EAAE,oBAAoB,YAAA;IAG3D;;;;;;OAMG;IACI,uBAAuB,IAAI,oBAAoB,EAAE;IA6BxD;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IA0B3B;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;IAiCjC;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,SAAS;IAsDjB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IA0BpB;;;;;;;;;OASG;IACH,MAAM,CAAC,0BAA0B,CAC7B,UAAU,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAI,MAAM,GAAG,SAAS;CAgBzE"}
+{"version":3,"file":"ap214_product_structure_extraction.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_product_structure_extraction.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAkBhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IAEnC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ,2FAA2F;IAC3F,IAAI,EAAE,MAAM,CAAA;IAEZ,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAA;IAElC,mEAAmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B;;;;OAIG;IACH,cAAc,EAAE,MAAM,EAAE,CAAA;IAExB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAEhC,0EAA0E;IAC1E,QAAQ,EAAE,oBAAoB,EAAE,CAAA;IAEhC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IAEtC;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B;;;;;;OAMG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAA;CACpC;AAED,yEAAyE;AACzE,eAAO,MAAM,8BAA8B,MAAM,CAAA;AAEjD,gFAAgF;AAChF,eAAO,MAAM,sCAAsC,KAAK,CAAA;AAmDxD;;;;;;;;;GASG;AACH,qBAAa,+BAA+B;IAqBtC,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;IApBrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsD;IACrF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAoB;IACxD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwC;IACxE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA8B;IACrE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAoC;IACxE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiC;IACvE,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,oBAAoB,CAAiC;IAC7D,OAAO,CAAC,2BAA2B,CAAyC;IAE5E;;;;;;;OAOG;gBAEkB,KAAK,EAAE,cAAc,EACrB,eAAe,CAAC,EAAE,oBAAoB,YAAA;IAG3D;;;;;;;;;OASG;IACI,uBAAuB,CAAE,OAAO,CAAC,EAAE,uBAAuB,GAAI,oBAAoB,EAAE;IAuC3F;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IA0B3B;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;IAiCjC;;;;;;;;;OASG;IACH,OAAO,CAAC,WAAW;IAuEnB;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;IAoBhB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,SAAS;IA2DjB;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;IA2C3B;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IA0BpB;;;;;;;;;OASG;IACH,MAAM,CAAC,0BAA0B,CAC7B,UAAU,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,GAAI,MAAM,GAAG,SAAS;CAgBzE"}

package/compiled/src/AP214E3_2010/ap214_product_structure_extraction.js

@@ -1,10 +1,45 @@
+import { face_based_surface_model } from "./AP214E3_2010_gen/face_based_surface_model.gen.js";
+import { manifold_solid_brep } from "./AP214E3_2010_gen/manifold_solid_brep.gen.js";
 import { next_assembly_usage_occurrence } from "./AP214E3_2010_gen/next_assembly_usage_occurrence.gen.js";
 import { product_definition } from "./AP214E3_2010_gen/product_definition.gen.js";
 import { product_definition_shape } from "./AP214E3_2010_gen/product_definition_shape.gen.js";
+import { representation_relationship_with_transformation, } from "./AP214E3_2010_gen/representation_relationship_with_transformation.gen.js";
 import { shape_definition_representation } from "./AP214E3_2010_gen/shape_definition_representation.gen.js";
+import { shape_representation_relationship, } from "./AP214E3_2010_gen/shape_representation_relationship.gen.js";
+import { shell_based_surface_model } from "./AP214E3_2010_gen/shell_based_surface_model.gen.js";
+/** Default hard cap on emitted solid children per product occurrence. */
+export const DEFAULT_MAX_SOLIDS_PER_PRODUCT = 256;
+/** Default suppression threshold for a product whose solids are all unnamed. */
+export const DEFAULT_MAX_UNNAMED_SOLIDS_PER_PRODUCT = 32;
+/** Minimum solids in a product before the ephemeral layer adds anything. */
+const MIN_SOLIDS_FOR_EPHEMERAL = 2;
 /** Readable node-kind strings for {@link ProductStructureNode.type}. */
 const ROOT_NODE_TYPE = "product";
 const OCCURRENCE_NODE_TYPE = "product_occurrence";
+const SOLID_NODE_TYPE = "solid";
+/**
+ * Whether a representation-item name carries meaning (non-empty and not an
+ * exporter placeholder).
+ *
+ * @param name The item name.
+ * @return {boolean} True when the name is worth displaying.
+ */
+function isMeaningfulName(name) {
+    return name.length > 0 && name !== "NONE" && name !== "UNKNOWN";
+}
+/**
+ * Whether a representation item is a solid-level body that can anchor an
+ * ephemeral node ({@link manifold_solid_brep} covers its `brep_with_voids` /
+ * `faceted_brep` subtypes).
+ *
+ * @param item The representation item.
+ * @return {boolean} True for solid-level items.
+ */
+function isSolidItem(item) {
+    return item instanceof manifold_solid_brep ||
+        item instanceof shell_based_surface_model ||
+        item instanceof face_based_surface_model;
+}
 /**
  * Extracts the STEP product / assembly structure from a populated
  * {@link AP214StepModel} into a nested, named, occurrence-keyed tree.
@@ -31,18 +66,34 @@ export class AP214ProductStructureExtraction {
         this.childProductDefIds_ = new Set();
         this.productDefById_ = new Map();
         this.shapeRepsByProductDef_ = new Map();
+        this.solidsByProductDef_ = new Map();
+        this.solidIdsByProductDef_ = new Map();
+        this.includeSolids_ = false;
+        this.maxSolidsPerProduct_ = DEFAULT_MAX_SOLIDS_PER_PRODUCT;
+        this.maxUnnamedSolidsPerProduct_ = DEFAULT_MAX_UNNAMED_SOLIDS_PER_PRODUCT;
     }
     /**
      * Build the product-structure tree.
      *
+     * @param options Optional {@link ProductStructureOptions}; pass
+     * `{ includeSolids: true }` to add the ephemeral solid layer beneath
+     * multibody products.
      * @return {ProductStructureNode[]} The roots of the assembly forest. A
      * single-part file yields one root; a multi-level assembly (e.g. `as1`) yields
      * one root whose descendants are the NAUO occurrences.
      */
-    extractProductStructure() {
+    extractProductStructure(options) {
+        this.includeSolids_ = options?.includeSolids ?? false;
+        this.maxSolidsPerProduct_ =
+            options?.maxSolidsPerProduct ?? DEFAULT_MAX_SOLIDS_PER_PRODUCT;
+        this.maxUnnamedSolidsPerProduct_ =
+            options?.maxUnnamedSolidsPerProduct ?? DEFAULT_MAX_UNNAMED_SOLIDS_PER_PRODUCT;
         this.indexProductDefinitions();
         this.indexAssemblyUsages();
         this.indexShapeRepresentations();
+        if (this.includeSolids_) {
+            this.indexSolids();
+        }
         const roots = [];
         for (const [productDefId, productDef] of this.productDefById_) {
             if (this.childProductDefIds_.has(productDefId)) {
@@ -124,6 +175,90 @@ export class AP214ProductStructureExtraction {
             }
         }
     }
+    /**
+     * Index the solid-level bodies of each product definition for the ephemeral
+     * layer: walk each `shape_definition_representation`'s representation, plus
+     * any representation reachable over a *plain* `shape_representation_relationship`
+     * (SolidWorks binds a part's multibody `advanced_brep_shape_representation`
+     * to its SDR-bound representation that way — the NEMA motor pattern), and
+     * collect the solid items. Transformation-bearing relationship variants are
+     * assembly placements (parent rep ↔ child rep), so following them would leak
+     * every child part's solids into its parent assembly; they are skipped.
+     */
+    indexSolids() {
+        const relatedRepsByRepId = new Map();
+        const relate = (fromId, to) => {
+            if (fromId === void 0) {
+                return;
+            }
+            let related = relatedRepsByRepId.get(fromId);
+            if (related === void 0) {
+                related = [];
+                relatedRepsByRepId.set(fromId, related);
+            }
+            related.push(to);
+        };
+        for (const element of this.model.types(shape_representation_relationship)) {
+            const srr = element;
+            if (srr.findVariant(representation_relationship_with_transformation) !== void 0) {
+                continue;
+            }
+            const rep1 = srr.rep_1;
+            const rep2 = srr.rep_2;
+            if (rep1 === void 0 || rep2 === void 0) {
+                continue;
+            }
+            // The geometry-bearing representation may be on either side; bridge both
+            // ways and let solid-item filtering pick out the bodies.
+            relate(rep1.expressID, rep2);
+            relate(rep2.expressID, rep1);
+        }
+        for (const element of this.model.types(shape_definition_representation)) {
+            const sdr = element;
+            const productDefId = AP214ProductStructureExtraction.resolveProductDefinitionId(sdr.definition);
+            const usedRep = sdr.used_representation;
+            if (productDefId === void 0 || usedRep === void 0) {
+                continue;
+            }
+            const reps = [usedRep, ...(relatedRepsByRepId.get(usedRep.expressID ?? -1) ?? [])];
+            for (const rep of reps) {
+                for (const item of rep.items) {
+                    if (!isSolidItem(item) || item.expressID === void 0) {
+                        continue;
+                    }
+                    this.addSolid(productDefId, {
+                        expressID: item.expressID,
+                        name: item.name,
+                        representationId: rep.expressID,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Record a solid for a product definition, de-duplicating by the solid's
+     * express id (a body can be reachable both directly and over a
+     * representation relationship).
+     *
+     * @param productDefId The owning product definition express id.
+     * @param solid The solid to record.
+     */
+    addSolid(productDefId, solid) {
+        let solids = this.solidsByProductDef_.get(productDefId);
+        let solidIds = this.solidIdsByProductDef_.get(productDefId);
+        if (solids === void 0 || solidIds === void 0) {
+            solids = [];
+            solidIds = new Set();
+            this.solidsByProductDef_.set(productDefId, solids);
+            this.solidIdsByProductDef_.set(productDefId, solidIds);
+        }
+        // Set-backed dedup: a linear scan here is quadratic over a product's
+        // solids, and a single product can hold tens of thousands (DSA2).
+        if (!solidIds.has(solid.expressID)) {
+            solidIds.add(solid.expressID);
+            solids.push(solid);
+        }
+    }
     /**
      * Record a shape-representation id for a product definition, de-duplicating.
      *
@@ -169,24 +304,69 @@ export class AP214ProductStructureExtraction {
             children: [],
         };
         const childUsages = this.nauosByParent_.get(productDefId);
-        if (childUsages === void 0 || onPath.has(productDefId)) {
-            return node;
-        }
-        onPath.add(productDefId);
-        for (const childUsage of childUsages) {
-            const childDefId = childUsage.related_product_definition?.expressID;
-            if (childDefId === void 0) {
-                continue;
-            }
-            const childDef = this.productDefById_.get(childDefId);
-            if (childDef === void 0) {
-                continue;
+        if (childUsages !== void 0 && !onPath.has(productDefId)) {
+            onPath.add(productDefId);
+            for (const childUsage of childUsages) {
+                const childDefId = childUsage.related_product_definition?.expressID;
+                if (childDefId === void 0) {
+                    continue;
+                }
+                const childDef = this.productDefById_.get(childDefId);
+                if (childDef === void 0) {
+                    continue;
+                }
+                node.children.push(this.buildNode(childDef, childUsage, occurrencePath, onPath));
             }
-            node.children.push(this.buildNode(childDef, childUsage, occurrencePath, onPath));
+            onPath.delete(productDefId);
+        }
+        // Ephemeral solids come after the occurrence children: they are the
+        // lighter-weight entries of the two.
+        if (this.includeSolids_) {
+            this.appendSolidChildren(node);
         }
-        onPath.delete(productDefId);
         return node;
     }
+    /**
+     * Append this node's ephemeral solid children, applying the layer's
+     * heuristics (see {@link ProductStructureOptions}): nothing for a
+     * single-solid product, full suppression for oversized all-unnamed sets,
+     * and the hard per-product cap — suppressed/overflow counts are surfaced
+     * via {@link ProductStructureNode.droppedSolids}.
+     *
+     * @param node The product/occurrence node to attach solid children to.
+     */
+    appendSolidChildren(node) {
+        const solids = this.solidsByProductDef_.get(node.productDefinitionExpressID);
+        if (solids === void 0 || solids.length < MIN_SOLIDS_FOR_EPHEMERAL) {
+            return;
+        }
+        const hasNamedSolid = solids.some((solid) => isMeaningfulName(solid.name));
+        if (!hasNamedSolid && solids.length > this.maxUnnamedSolidsPerProduct_) {
+            node.droppedSolids = solids.length;
+            return;
+        }
+        let emitted = solids;
+        if (solids.length > this.maxSolidsPerProduct_) {
+            emitted = solids.slice(0, this.maxSolidsPerProduct_);
+            node.droppedSolids = solids.length - emitted.length;
+        }
+        for (let index = 0; index < emitted.length; ++index) {
+            const solid = emitted[index];
+            node.children.push({
+                expressID: solid.expressID,
+                type: SOLID_NODE_TYPE,
+                name: isMeaningfulName(solid.name) ?
+                    solid.name : `Solid ${index + 1} of ${solids.length}`,
+                productDefinitionExpressID: node.productDefinitionExpressID,
+                // A solid is not an occurrence: the path stays NAUO-only, and the
+                // selection identity is the (occurrencePath, expressID) pair.
+                occurrencePath: [...node.occurrencePath],
+                shapeRepresentationIds: solid.representationId !== void 0 ? [solid.representationId] : [],
+                children: [],
+                ephemeral: true,
+            });
+        }
+    }
     /**
      * Resolve a node label, preferring the product name, then the occurrence's
      * own name / reference designator.

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

@@ -6,19 +6,29 @@ import { ParseResult } from "../step/parsing/step_parser.js";
 import { AP214ProductStructureExtraction, } from "./ap214_product_structure_extraction.js";
 const parser = AP214StepParser.Instance;
 /**
- * Parse the hermetic as1 assembly fixture and extract its product structure.
+ * Parse a hermetic fixture and extract its product structure.
  *
+ * @param path The fixture path.
+ * @param options Optional extraction options (e.g. the ephemeral solid layer).
  * @return {ProductStructureNode[]} The extracted assembly forest.
  */
-function extractAs1Structure() {
-    const buffer = fs.readFileSync("data/as1-assembly.step");
+function extractStructure(path, options) {
+    const buffer = fs.readFileSync(path);
     const bufferInput = new ParsingBuffer(buffer);
     const headerResult = parser.parseHeader(bufferInput)[1];
     expect(headerResult).toBe(ParseResult.COMPLETE);
     const [result, model] = parser.parseDataToModel(bufferInput);
     expect(model).not.toBe(void 0);
     expect(result === ParseResult.COMPLETE || result === ParseResult.INCOMPLETE).toBe(true);
-    return new AP214ProductStructureExtraction(model).extractProductStructure();
+    return new AP214ProductStructureExtraction(model).extractProductStructure(options);
+}
+/**
+ * Parse the hermetic as1 assembly fixture and extract its product structure.
+ *
+ * @return {ProductStructureNode[]} The extracted assembly forest.
+ */
+function extractAs1Structure() {
+    return extractStructure("data/as1-assembly.step");
 }
 /**
  * Find a direct child of a node by display name.
@@ -105,3 +115,86 @@ describe("AP214ProductStructureExtraction", () => {
         expect(root.children.length).toBe(AS1_ROOT_CHILD_COUNT);
     });
 });
+const MULTIBODY_FIXTURE = "data/ap214-multibody-part.step";
+const WIDGET_SOLID_COUNT = 3;
+const SOUP_SOLID_COUNT = 3;
+/**
+ * Collect the ephemeral solid children of a node.
+ *
+ * @param node The parent node.
+ * @return {ProductStructureNode[]} The `type: 'solid'` children.
+ */
+function solidChildren(node) {
+    return node.children.filter((candidate) => candidate.type === "solid");
+}
+describe("AP214ProductStructureExtraction ephemeral solid layer", () => {
+    test("is off by default: no solid nodes anywhere", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE)[0];
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            expect(node.type).not.toBe("solid");
+            expect(node.ephemeral).toBe(void 0);
+            stack.push(...node.children);
+        }
+    });
+    test("surfaces named multibody solids beneath each occurrence", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE, { includeSolids: true })[0];
+        const widgets = root.children.filter((node) => node.name === "widget");
+        expect(widgets.length).toBe(2);
+        for (const widget of widgets) {
+            const solids = solidChildren(widget);
+            expect(solids.length).toBe(WIDGET_SOLID_COUNT);
+            // Named bodies keep their file names; the unnamed one gets a
+            // positional fallback.
+            expect(solids.map((solid) => solid.name))
+                .toEqual(["Body1", "Body2", "Solid 3 of 3"]);
+            for (const solid of solids) {
+                expect(solid.ephemeral).toBe(true);
+                expect(solid.children.length).toBe(0);
+                expect(solid.productDefinitionExpressID)
+                    .toBe(widget.productDefinitionExpressID);
+                // A solid is not an occurrence: it inherits the parent's NAUO-only
+                // path, and (path, expressID) is the selection identity.
+                expect(solid.occurrencePath).toEqual(widget.occurrencePath);
+            }
+        }
+        // The same part type under two occurrences repeats the same solid ids —
+        // the occurrence path is what tells the instances apart.
+        expect(solidChildren(widgets[0]).map((solid) => solid.expressID))
+            .toEqual(solidChildren(widgets[1]).map((solid) => solid.expressID));
+        expect(widgets[0].occurrencePath).not.toEqual(widgets[1].occurrencePath);
+    });
+    test("leaves single-solid products and the assembly root alone", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE, { includeSolids: true })[0];
+        // The widget solids live in a representation bridged to the assembly's
+        // representation by a transformation-bearing relationship (an assembly
+        // placement); following it would leak child solids into the parent.
+        expect(solidChildren(root).length).toBe(0);
+        const pin = root.children.find((node) => node.name === "pin");
+        // One solid maps 1:1 onto the product node itself; a child adds nothing.
+        expect(solidChildren(pin).length).toBe(0);
+        expect(pin.droppedSolids).toBe(void 0);
+    });
+    test("suppresses oversized all-unnamed solid sets and reports the drop", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE, { includeSolids: true, maxUnnamedSolidsPerProduct: 2 })[0];
+        const soup = root.children.find((node) => node.name === "soup");
+        expect(solidChildren(soup).length).toBe(0);
+        expect(soup.droppedSolids).toBe(SOUP_SOLID_COUNT);
+    });
+    test("emits small all-unnamed sets with positional names", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE, { includeSolids: true })[0];
+        const soup = root.children.find((node) => node.name === "soup");
+        expect(solidChildren(soup).map((solid) => solid.name))
+            .toEqual(["Solid 1 of 3", "Solid 2 of 3", "Solid 3 of 3"]);
+    });
+    test("caps per-product solids and reports the overflow", () => {
+        const root = extractStructure(MULTIBODY_FIXTURE, { includeSolids: true, maxSolidsPerProduct: 2 })[0];
+        const widget = root.children.find((node) => node.name === "widget");
+        const solids = solidChildren(widget);
+        expect(solids.length).toBe(2);
+        expect(widget.droppedSolids).toBe(WIDGET_SOLID_COUNT - 2);
+        // Truncated, not renumbered: positions stay stable under the cap.
+        expect(solids.map((solid) => solid.name)).toEqual(["Body1", "Body2"]);
+    });
+});

package/compiled/src/compat/web-ifc/ap214_properties.d.ts

@@ -1,5 +1,5 @@
 import { IfcApiProxyAP214 } from "./ifc_api_proxy_ap214.js";
-import { IncludeProperties, Node } from "./properties_passthrough.js";
+import { IncludeProperties, Node, SpatialStructureOptions } from "./properties_passthrough.js";
 /**
  * web-ifc-compatible property/spatial surface over an AP214/AP242 step model.
  *
@@ -15,6 +15,7 @@ import { IncludeProperties, Node } from "./properties_passthrough.js";
 export declare class AP214Properties {
     private api;
     private structureRoots_?;
+    private structureRootsWithSolids_?;
     private propertyMap_?;
     private ownerByExpressID_?;
     private nodeNameByExpressID_?;
@@ -85,10 +86,13 @@ export declare class AP214Properties {
      *
      * @param includeProperties When true, merge each node's item properties onto
      * the node (mirrors the IFC surface's `includeProperties`).
+     * @param options Optional shaping: `{ includeSolids: true }` adds the
+     * ephemeral solid layer beneath multibody products (`type: 'solid'`,
+     * `ephemeral: true` nodes) — see `design/new/step-nonproduct-semantics.md`.
      * @return {Promise<Node>} The root node. A single-root file returns its root
      * directly; a multi-root file is wrapped in a synthetic container root.
      */
-    getSpatialStructure(includeProperties?: IncludeProperties): Promise<Node>;
+    getSpatialStructure(includeProperties?: IncludeProperties, options?: SpatialStructureOptions): Promise<Node>;
     /**
      * Get every element of a STEP entity type, backed by the model type index.
      *
@@ -146,6 +150,16 @@ export declare class AP214Properties {
      * @return {ProductStructureNode[]} The cached assembly roots.
      */
     private productStructure;
+    /**
+     * Return (and cache) the product-structure forest with the ephemeral solid
+     * layer included. Built separately from the plain forest so default callers
+     * never pay for the solid walk; the solid nodes are also indexed so
+     * `getItemProperties` resolves a solid id to its identity row and
+     * `getPropertySets` maps it to the owning product's rows.
+     *
+     * @return {ProductStructureNode[]} The cached solid-including roots.
+     */
+    private productStructureWithSolids;
     /**
      * Lazily build and cache the extracted property map.
      *

package/compiled/src/compat/web-ifc/ap214_properties.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ap214_properties.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ap214_properties.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AAuGlE;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAWb,OAAO,CAAC,GAAG;IATxB,OAAO,CAAC,eAAe,CAAC,CAAwB;IAChD,OAAO,CAAC,YAAY,CAAC,CAAsB;IAC3C,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,oBAAoB,CAAC,CAAqB;IAClD,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAE1D;;OAEG;gBACkB,GAAG,EAAE,gBAAgB;IAG1C;;;;;;OAMG;IACH,UAAU,CAAE,IAAI,EAAE,MAAM,GAAI,MAAM;IAIlC;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CAAE,EAAE,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,MAAM,CAAC;IAoBzE;;;;;;;;;;;OAWG;IACG,eAAe,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAkD7E;;;;;;OAMG;IACG,iBAAiB,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAI/E;;;;;;OAMG;IACG,sBAAsB,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAIpF;;;;;;;OAOG;IACG,mBAAmB,CAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAI,OAAO,CAAC,IAAI,CAAC;IAuBjF;;;;;;OAMG;IACG,iBAAiB,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAmBzE;;;;;;;OAOG;YACW,aAAa;IA4B3B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;;;;;;OASG;IACH;;;;;;OAMG;IACI,YAAY,IAAI,IAAI;IAI3B,OAAO,CAAC,YAAY;IA6BpB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAUlB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;OAIG;IACH,OAAO,CAAC,UAAU;CAQnB"}
+{"version":3,"file":"ap214_properties.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ap214_properties.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EACL,iBAAiB,EACjB,IAAI,EACJ,uBAAuB,EACxB,MAAM,0BAA0B,CAAA;AAiHjC;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAYb,OAAO,CAAC,GAAG;IAVxB,OAAO,CAAC,eAAe,CAAC,CAAwB;IAChD,OAAO,CAAC,yBAAyB,CAAC,CAAwB;IAC1D,OAAO,CAAC,YAAY,CAAC,CAAsB;IAC3C,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,oBAAoB,CAAC,CAAqB;IAClD,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAE1D;;OAEG;gBACkB,GAAG,EAAE,gBAAgB;IAG1C;;;;;;OAMG;IACH,UAAU,CAAE,IAAI,EAAE,MAAM,GAAI,MAAM;IAIlC;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CAAE,EAAE,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,MAAM,CAAC;IAoBzE;;;;;;;;;;;OAWG;IACG,eAAe,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAkD7E;;;;;;OAMG;IACG,iBAAiB,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAI/E;;;;;;OAMG;IACG,sBAAsB,CAAE,SAAS,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAIpF;;;;;;;;;;OAUG;IACG,mBAAmB,CACrB,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,OAAO,CAAC,EAAE,uBAAuB,GAAI,OAAO,CAAC,IAAI,CAAC;IAwBtD;;;;;;OAMG;IACG,iBAAiB,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAmBzE;;;;;;;OAOG;YACW,aAAa;IAoC3B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;;;;;;OASG;IACH;;;;;;OAMG;IACI,YAAY,IAAI,IAAI;IAI3B,OAAO,CAAC,YAAY;IA6BpB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAUlB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IAkBlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;CAQnB"}