@bldrs-ai/conway 1.346.1102 → 1.347.1107

package/compiled/examples/browser-bundled.cjs

@@ -69608,7 +69608,7 @@ var IfcStepParser = class extends StepParser {
 IfcStepParser.Instance = new IfcStepParser();
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.346.1102";
+var versionString = "Conway Web-Ifc Shim v1.347.1107";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

package/compiled/examples/cli-bundled.cjs

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

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

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

package/compiled/examples/validator-bundled.cjs

@@ -69606,7 +69606,7 @@ var IfcStepParser = class extends StepParser {
 IfcStepParser.Instance = new IfcStepParser();
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.346.1102";
+var versionString = "Conway Web-Ifc Shim v1.347.1107";
 
 // compiled/src/statistics/statistics.js
 var Statistics = class {

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

@@ -0,0 +1,144 @@
+import AP214StepModel from "./ap214_step_model.js";
+import { AP214ProductShapeMap } from "./ap214_product_shape_map.js";
+/**
+ * A node in the extracted STEP product / assembly structure.
+ *
+ * The structure is *occurrence*-keyed, not product-keyed: STEP instancing lets
+ * one `product_definition` (a part *type*) appear many times in an assembly via
+ * distinct `next_assembly_usage_occurrence` (NAUO) edges. A scalar express id of
+ * the product cannot tell two visual instances apart, so each occurrence node
+ * carries both its NAUO express id (`expressID`) and the ordered
+ * `occurrencePath` (root→node, NAUO ids) that is the stable
+ * selection / permalink token. See
+ * `design/new/step-metadata-nist.md` §"Occurrence identity".
+ *
+ * This is the forcing function for Share's goal of generalizing its scalar
+ * `expressID` selection key into a format-agnostic *occurrence path* — flag it
+ * wherever this tree is consumed Share-side.
+ */
+export interface ProductStructureNode {
+    /**
+     * Node selection key. For an occurrence node this is the NAUO express id; for
+     * a root (single-part files have no NAUO) it falls back to the
+     * `product_definition` express id.
+     */
+    expressID: number;
+    /** Readable node kind: `'product'` for roots, `'product_occurrence'` for NAUO nodes. */
+    type: string;
+    /** Display label: `product.name`, falling back to the NAUO name / reference designator. */
+    name: string;
+    /** Express id of the underlying `product_definition` (the part *type*). */
+    productDefinitionExpressID: number;
+    /** NAUO express id for occurrence nodes; `undefined` for roots. */
+    occurrenceExpressID?: number;
+    /**
+     * Ordered occurrence path (NAUO express ids) from the top-level occurrence to
+     * this node. Empty for roots. Disambiguates instances of the same part — e.g.
+     * `[3810, 1921, 1910]` vs `[6217, 1921, 1910]` for the two bolts in `as1`.
+     */
+    occurrencePath: number[];
+    /**
+     * Shape representation express ids linked to this part (via
+     * `product_definition_shape` → `shape_definition_representation`). The seam to
+     * scene geometry for NavTree-click ⇄ viewport-pick round-tripping.
+     */
+    shapeRepresentationIds: number[];
+    /** Child occurrence nodes. */
+    children: ProductStructureNode[];
+}
+/**
+ * Extracts the STEP product / assembly structure from a populated
+ * {@link AP214StepModel} into a nested, named, occurrence-keyed tree.
+ *
+ * Mirrors the IFC precedent (`src/ifc/ifc_property_extraction.ts`) but for
+ * AP214/AP242: walks `product` / `product_definition` /
+ * `next_assembly_usage_occurrence` into a tree, resolves labels from
+ * `product.name`, and links each part to its shape representations so a NavTree
+ * node can highlight the right geometry instance.
+ */
+export declare class AP214ProductStructureExtraction {
+    private readonly model;
+    private readonly productShapeMap?;
+    private readonly nauosByParent_;
+    private readonly childProductDefIds_;
+    private readonly productDefById_;
+    private readonly shapeRepsByProductDef_;
+    /**
+     * @param model The populated AP214/AP242 step model to walk.
+     * @param productShapeMap Optional product↔shape map populated during geometry
+     * extraction. When provided its links are merged with the ones derived here so
+     * the tree's `shapeRepresentationIds` agree with the scene; the map is empty
+     * unless geometry extraction has run, so the entity-graph walk below is the
+     * primary source.
+     */
+    constructor(model: AP214StepModel, productShapeMap?: AP214ProductShapeMap | undefined);
+    /**
+     * Build the product-structure tree.
+     *
+     * @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[];
+    /**
+     * Index every `product_definition` by express id for O(1) lookup during the
+     * recursive walk.
+     */
+    private indexProductDefinitions;
+    /**
+     * Index every NAUO by its parent (`relating_product_definition`) express id
+     * and record which product definitions appear as a child
+     * (`related_product_definition`) so roots can be identified.
+     */
+    private indexAssemblyUsages;
+    /**
+     * Link product definitions to their shape representations by walking
+     * `shape_definition_representation` → `product_definition_shape` →
+     * `product_definition`, and merge any links already present in the
+     * geometry-extraction product↔shape map.
+     */
+    private indexShapeRepresentations;
+    /**
+     * Record a shape-representation id for a product definition, de-duplicating.
+     *
+     * @param productDefId The product definition express id.
+     * @param shapeId The shape representation express id to associate.
+     */
+    private addShapeRepresentation;
+    /**
+     * Recursively build a tree node for one product-definition occurrence.
+     *
+     * @param productDef The product definition this node represents.
+     * @param occurrence The NAUO edge that introduced this occurrence, or
+     * `undefined` for a root.
+     * @param parentPath The occurrence path of the parent node (NAUO ids).
+     * @param onPath Product-definition ids currently on the recursion stack;
+     * guards against a malformed cyclic assembly causing infinite recursion (a
+     * legitimately re-used part in sibling branches is unaffected).
+     * @return {ProductStructureNode} The built node, with children.
+     */
+    private buildNode;
+    /**
+     * Resolve a node label, preferring the product name, then the occurrence's
+     * own name / reference designator.
+     *
+     * @param productDef The product definition for the node.
+     * @param occurrence The NAUO edge, when this is an occurrence node.
+     * @return {string} The best available human-readable label.
+     */
+    private resolveLabel;
+    /**
+     * Resolve the owning `product_definition` express id from a
+     * `property_definition`-style `definition` select. Handles the direct
+     * `product_definition` case and the `product_definition_shape` indirection
+     * (its own `definition` points at the product definition).
+     *
+     * @param definition The resolved `definition` reference, or `undefined`.
+     * @return {number | undefined} The product definition express id, or
+     * `undefined` if it does not resolve to one.
+     */
+    static resolveProductDefinitionId(definition: {
+        expressID?: number;
+    } | undefined): number | undefined;
+}
+//# sourceMappingURL=ap214_product_structure_extraction.d.ts.map

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

@@ -0,0 +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,kCAAsB;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"}

package/compiled/src/AP214E3_2010/ap214_product_structure_extraction.js

@@ -0,0 +1,236 @@
+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 { shape_definition_representation } from "./AP214E3_2010_gen/shape_definition_representation.gen.js";
+/** Readable node-kind strings for {@link ProductStructureNode.type}. */
+const ROOT_NODE_TYPE = "product";
+const OCCURRENCE_NODE_TYPE = "product_occurrence";
+/**
+ * Extracts the STEP product / assembly structure from a populated
+ * {@link AP214StepModel} into a nested, named, occurrence-keyed tree.
+ *
+ * Mirrors the IFC precedent (`src/ifc/ifc_property_extraction.ts`) but for
+ * AP214/AP242: walks `product` / `product_definition` /
+ * `next_assembly_usage_occurrence` into a tree, resolves labels from
+ * `product.name`, and links each part to its shape representations so a NavTree
+ * node can highlight the right geometry instance.
+ */
+export class AP214ProductStructureExtraction {
+    /**
+     * @param model The populated AP214/AP242 step model to walk.
+     * @param productShapeMap Optional product↔shape map populated during geometry
+     * extraction. When provided its links are merged with the ones derived here so
+     * the tree's `shapeRepresentationIds` agree with the scene; the map is empty
+     * unless geometry extraction has run, so the entity-graph walk below is the
+     * primary source.
+     */
+    constructor(model, productShapeMap) {
+        this.model = model;
+        this.productShapeMap = productShapeMap;
+        this.nauosByParent_ = new Map();
+        this.childProductDefIds_ = new Set();
+        this.productDefById_ = new Map();
+        this.shapeRepsByProductDef_ = new Map();
+    }
+    /**
+     * Build the product-structure tree.
+     *
+     * @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() {
+        this.indexProductDefinitions();
+        this.indexAssemblyUsages();
+        this.indexShapeRepresentations();
+        const roots = [];
+        for (const [productDefId, productDef] of this.productDefById_) {
+            if (this.childProductDefIds_.has(productDefId)) {
+                continue;
+            }
+            // A genuine root is a part: it has geometry and/or sub-assembly children.
+            // This excludes stray product_definitions referenced only by metadata.
+            const hasChildren = this.nauosByParent_.has(productDefId);
+            const hasShape = this.shapeRepsByProductDef_.has(productDefId);
+            if (!hasChildren && !hasShape) {
+                continue;
+            }
+            roots.push(this.buildNode(productDef, undefined, [], new Set()));
+        }
+        return roots;
+    }
+    /**
+     * Index every `product_definition` by express id for O(1) lookup during the
+     * recursive walk.
+     */
+    indexProductDefinitions() {
+        for (const element of this.model.types(product_definition)) {
+            const productDef = element;
+            const expressID = productDef.expressID;
+            if (expressID !== void 0) {
+                this.productDefById_.set(expressID, productDef);
+            }
+        }
+    }
+    /**
+     * Index every NAUO by its parent (`relating_product_definition`) express id
+     * and record which product definitions appear as a child
+     * (`related_product_definition`) so roots can be identified.
+     */
+    indexAssemblyUsages() {
+        for (const element of this.model.types(next_assembly_usage_occurrence)) {
+            const nauo = element;
+            const parentId = nauo.relating_product_definition?.expressID;
+            const childId = nauo.related_product_definition?.expressID;
+            if (parentId === void 0 || childId === void 0) {
+                continue;
+            }
+            this.childProductDefIds_.add(childId);
+            let siblings = this.nauosByParent_.get(parentId);
+            if (siblings === void 0) {
+                siblings = [];
+                this.nauosByParent_.set(parentId, siblings);
+            }
+            siblings.push(nauo);
+        }
+    }
+    /**
+     * Link product definitions to their shape representations by walking
+     * `shape_definition_representation` → `product_definition_shape` →
+     * `product_definition`, and merge any links already present in the
+     * geometry-extraction product↔shape map.
+     */
+    indexShapeRepresentations() {
+        for (const element of this.model.types(shape_definition_representation)) {
+            const sdr = element;
+            const productDefId = AP214ProductStructureExtraction.resolveProductDefinitionId(sdr.definition);
+            if (productDefId === void 0) {
+                continue;
+            }
+            // The shape id is the *used_representation* (the geometry), not the SDR's
+            // own id — falling back to `sdr.expressID` would store a non-geometry id
+            // that a pick-reconciliation consumer could not resolve to a scene mesh.
+            const shapeId = sdr.used_representation?.expressID;
+            if (shapeId !== void 0) {
+                this.addShapeRepresentation(productDefId, shapeId);
+            }
+        }
+        if (this.productShapeMap === void 0) {
+            return;
+        }
+        for (const [productDefId, shapes] of this.productShapeMap.productDefsToShapes()) {
+            for (const shapeId of shapes) {
+                this.addShapeRepresentation(productDefId, shapeId);
+            }
+        }
+    }
+    /**
+     * Record a shape-representation id for a product definition, de-duplicating.
+     *
+     * @param productDefId The product definition express id.
+     * @param shapeId The shape representation express id to associate.
+     */
+    addShapeRepresentation(productDefId, shapeId) {
+        let shapes = this.shapeRepsByProductDef_.get(productDefId);
+        if (shapes === void 0) {
+            shapes = [];
+            this.shapeRepsByProductDef_.set(productDefId, shapes);
+        }
+        if (!shapes.includes(shapeId)) {
+            shapes.push(shapeId);
+        }
+    }
+    /**
+     * Recursively build a tree node for one product-definition occurrence.
+     *
+     * @param productDef The product definition this node represents.
+     * @param occurrence The NAUO edge that introduced this occurrence, or
+     * `undefined` for a root.
+     * @param parentPath The occurrence path of the parent node (NAUO ids).
+     * @param onPath Product-definition ids currently on the recursion stack;
+     * guards against a malformed cyclic assembly causing infinite recursion (a
+     * legitimately re-used part in sibling branches is unaffected).
+     * @return {ProductStructureNode} The built node, with children.
+     */
+    buildNode(productDef, occurrence, parentPath, onPath) {
+        const productDefId = productDef.expressID;
+        const label = this.resolveLabel(productDef, occurrence);
+        const occurrenceExpressID = occurrence?.expressID;
+        const occurrencePath = occurrenceExpressID !== void 0 ?
+            [...parentPath, occurrenceExpressID] : [...parentPath];
+        const node = {
+            expressID: occurrenceExpressID ?? productDefId,
+            type: occurrence !== void 0 ? OCCURRENCE_NODE_TYPE : ROOT_NODE_TYPE,
+            name: label,
+            productDefinitionExpressID: productDefId,
+            occurrenceExpressID,
+            occurrencePath,
+            shapeRepresentationIds: this.shapeRepsByProductDef_.get(productDefId) ?? [],
+            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;
+            }
+            node.children.push(this.buildNode(childDef, childUsage, occurrencePath, onPath));
+        }
+        onPath.delete(productDefId);
+        return node;
+    }
+    /**
+     * Resolve a node label, preferring the product name, then the occurrence's
+     * own name / reference designator.
+     *
+     * @param productDef The product definition for the node.
+     * @param occurrence The NAUO edge, when this is an occurrence node.
+     * @return {string} The best available human-readable label.
+     */
+    resolveLabel(productDef, occurrence) {
+        const productName = productDef.formation?.of_product?.name;
+        if (productName !== void 0 && productName.length > 0) {
+            return productName;
+        }
+        if (occurrence !== void 0) {
+            if (occurrence.name.length > 0) {
+                return occurrence.name;
+            }
+            const referenceDesignator = occurrence.reference_designator;
+            if (referenceDesignator !== null && referenceDesignator.length > 0) {
+                return referenceDesignator;
+            }
+        }
+        return productDef.name ?? "";
+    }
+    /**
+     * Resolve the owning `product_definition` express id from a
+     * `property_definition`-style `definition` select. Handles the direct
+     * `product_definition` case and the `product_definition_shape` indirection
+     * (its own `definition` points at the product definition).
+     *
+     * @param definition The resolved `definition` reference, or `undefined`.
+     * @return {number | undefined} The product definition express id, or
+     * `undefined` if it does not resolve to one.
+     */
+    static resolveProductDefinitionId(definition) {
+        if (definition === void 0) {
+            return void 0;
+        }
+        if (definition instanceof product_definition) {
+            return definition.expressID;
+        }
+        if (definition instanceof product_definition_shape) {
+            return AP214ProductStructureExtraction.resolveProductDefinitionId(definition.definition);
+        }
+        return void 0;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,107 @@
+import fs from "fs";
+import { describe, expect, test } from "@jest/globals";
+import AP214StepParser from "./ap214_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+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.
+ *
+ * @return {ProductStructureNode[]} The extracted assembly forest.
+ */
+function extractAs1Structure() {
+    const buffer = fs.readFileSync("data/as1-assembly.step");
+    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();
+}
+/**
+ * Find a direct child of a node by display name.
+ *
+ * @param node The parent node.
+ * @param name The child name to find.
+ * @return {ProductStructureNode} The first matching child.
+ */
+function child(node, name) {
+    const found = node.children.find((candidate) => candidate.name === name);
+    expect(found).not.toBe(void 0);
+    return found;
+}
+/**
+ * Names of the direct children of a node.
+ *
+ * @param node The parent node.
+ * @return {string[]} The child names, in order.
+ */
+function childNames(node) {
+    return node.children.map((candidate) => candidate.name);
+}
+const NUT_BOLT_ASSEMBLY_INSTANCE_COUNT = 3;
+const AS1_ROOT_CHILD_COUNT = 4;
+describe("AP214ProductStructureExtraction", () => {
+    test("extracts a single named root for the as1 assembly", () => {
+        const roots = extractAs1Structure();
+        expect(roots.length).toBe(1);
+        expect(roots[0].name).toBe("as1");
+        expect(roots[0].occurrencePath).toEqual([]);
+    });
+    test("builds the nested nut/rod/bracket/plate hierarchy with names", () => {
+        const root = extractAs1Structure()[0];
+        expect(childNames(root).sort()).toEqual(["l-bracket-assembly", "l-bracket-assembly", "plate", "rod-assembly"]);
+        const rodAssembly = child(root, "rod-assembly");
+        expect(childNames(rodAssembly).sort()).toEqual(["nut", "nut", "rod"]);
+        const lBracketAssembly = child(root, "l-bracket-assembly");
+        expect(childNames(lBracketAssembly).sort()).toEqual(["l-bracket", "nut-bolt-assembly", "nut-bolt-assembly", "nut-bolt-assembly"]);
+        const nutBoltAssembly = child(lBracketAssembly, "nut-bolt-assembly");
+        expect(childNames(nutBoltAssembly).sort()).toEqual(["bolt", "nut"]);
+    });
+    test("gives repeated sub-assembly occurrences distinct nodes and paths", () => {
+        const root = extractAs1Structure()[0];
+        const lBracketAssemblies = root.children.filter((node) => node.name === "l-bracket-assembly");
+        // Two occurrences of the SAME product_definition: same part type id...
+        expect(lBracketAssemblies.length).toBe(2);
+        expect(lBracketAssemblies[0].productDefinitionExpressID)
+            .toBe(lBracketAssemblies[1].productDefinitionExpressID);
+        // ...but distinct occurrence (NAUO) keys and distinct paths.
+        expect(lBracketAssemblies[0].expressID)
+            .not.toBe(lBracketAssemblies[1].expressID);
+        expect(lBracketAssemblies[0].occurrencePath)
+            .not.toEqual(lBracketAssemblies[1].occurrencePath);
+    });
+    test("disambiguates a reused leaf part by full occurrence path", () => {
+        const root = extractAs1Structure()[0];
+        const lBracketAssemblies = root.children.filter((node) => node.name === "l-bracket-assembly");
+        const boltPaths = lBracketAssemblies.map((assembly) => {
+            const nutBoltAssembly = child(assembly, "nut-bolt-assembly");
+            return child(nutBoltAssembly, "bolt").occurrencePath;
+        });
+        // Same leaf NAUO id at the tail, but the path roots differ — exactly the
+        // instancing case a scalar expressID cannot represent.
+        expect(boltPaths[0]).not.toEqual(boltPaths[1]);
+        expect(boltPaths[0][boltPaths[0].length - 1])
+            .toBe(boltPaths[1][boltPaths[1].length - 1]);
+        expect(boltPaths[0][0]).not.toBe(boltPaths[1][0]);
+    });
+    test("each nut-bolt-assembly occurrence has its own bolt and nut", () => {
+        const root = extractAs1Structure()[0];
+        const lBracketAssembly = child(root, "l-bracket-assembly");
+        const nutBoltAssemblies = lBracketAssembly.children.filter((node) => node.name === "nut-bolt-assembly");
+        expect(nutBoltAssemblies.length).toBe(NUT_BOLT_ASSEMBLY_INSTANCE_COUNT);
+        for (const nutBoltAssembly of nutBoltAssemblies) {
+            expect(childNames(nutBoltAssembly).sort()).toEqual(["bolt", "nut"]);
+        }
+    });
+    test("links the root part to its shape representation", () => {
+        const root = extractAs1Structure()[0];
+        expect(root.shapeRepresentationIds.length).toBeGreaterThan(0);
+    });
+    test("root has the expected number of top-level occurrences", () => {
+        const root = extractAs1Structure()[0];
+        expect(root.children.length).toBe(AS1_ROOT_CHILD_COUNT);
+    });
+});

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

@@ -0,0 +1,90 @@
+import AP214StepModel from "./ap214_step_model.js";
+/**
+ * One extracted key/value property row for a part.
+ */
+export interface ExtractedProperty {
+    /** Property key, e.g. `'Modeled By'`, `'volume measure'`. */
+    name: string;
+    /** Stringified value, e.g. `'Engineer'`, `'14644822.6361138'`. */
+    value: string;
+    /** Numeric value for measure properties (volume/area/…); `undefined` for text. */
+    numericValue?: number;
+    /**
+     * Grouping label from the owning `property_definition.name` — e.g.
+     * `'geometric validation property'` for NIST volume/area validation rows.
+     * Empty for plain attribute properties.
+     */
+    group: string;
+    /**
+     * Express id of the source representation item (the
+     * `descriptive_representation_item` / `measure_representation_item`). The
+     * compat surface uses it as the property's own express id so the web-ifc
+     * `IfcPropertySet.HasProperties` reference handles can be resolved back to
+     * this row via `getItemProperties`. `undefined` if the item carried no id.
+     */
+    expressID?: number;
+}
+/** Properties grouped by the express id of the owning `product_definition`. */
+export type ExtractedPropertyMap = Map<number, ExtractedProperty[]>;
+/** Minimal shape of a representation item needed for property conversion. */
+interface RepresentationItemLike {
+    name: string;
+    expressID?: number;
+}
+/**
+ * Extracts STEP part properties from a populated {@link AP214StepModel}.
+ *
+ * Walks the property chain
+ * `general_property` → (`general_property_association`) → `property_definition`
+ * → `property_definition_representation` → `representation` →
+ * `descriptive_representation_item` / `measure_representation_item` into
+ * per-part key/value rows. Includes the NIST validation properties
+ * (`geometric/attribute validation property`, e.g. volume via
+ * `measure_representation_item`).
+ *
+ * Mirrors the IFC precedent (`src/ifc/ifc_property_extraction.ts`); feeds the
+ * web-ifc compat surface `ap214_properties.ts` that Share consumes.
+ */
+export declare class AP214PropertyExtraction {
+    private readonly model;
+    private readonly generalPropertyNameByDef_;
+    /**
+     * @param model The populated AP214/AP242 step model to walk.
+     */
+    constructor(model: AP214StepModel);
+    /**
+     * Build the per-part property map.
+     *
+     * @return {ExtractedPropertyMap} Properties keyed by owning
+     * `product_definition` express id. Properties whose owner is a feature
+     * (`shape_aspect`, dimensions) rather than a part are skipped at this
+     * (Simplified) tier — they belong to the Full PMI tier.
+     */
+    extractProperties(): ExtractedPropertyMap;
+    /**
+     * Index general-property names by the express id of the `property_definition`
+     * they are associated with, so a property can carry the canonical
+     * `general_property` label when one exists.
+     */
+    private indexGeneralPropertyNames;
+    /**
+     * Resolve the part owner and value rows for one
+     * `property_definition_representation` and append them to the result map.
+     *
+     * @param pdr The property-definition representation to walk.
+     * @param result The accumulating per-part property map.
+     */
+    private collectFromRepresentation;
+    /**
+     * Convert a representation item into a property row, or `undefined` for item
+     * kinds that carry no key/value (e.g. a centroid `cartesian_point`).
+     *
+     * @param item The representation item to convert.
+     * @param fallbackKey Key to use when the item itself is unnamed.
+     * @param group Grouping label from the owning property definition.
+     * @return {ExtractedProperty | undefined} The property row, or `undefined`.
+     */
+    static toProperty(item: RepresentationItemLike, fallbackKey: string, group: string): ExtractedProperty | undefined;
+}
+export {};
+//# sourceMappingURL=ap214_property_extraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_property_extraction.d.ts","sourceRoot":"","sources":["../../../src/AP214E3_2010/ap214_property_extraction.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAU/C;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAEhC,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IAEZ,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IAEb,kFAAkF;IAClF,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,+EAA+E;AAC/E,MAAM,MAAM,oBAAoB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAA;AAEnE,6EAA6E;AAC7E,UAAU,sBAAsB;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,uBAAuB;IAOrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IALnC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IAEtE;;OAEG;gBAC2B,KAAK,EAAE,cAAc;IAGnD;;;;;;;OAOG;IACI,iBAAiB,IAAI,oBAAoB;IAsBhD;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAsBjC;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAgDjC;;;;;;;;OAQG;IACH,MAAM,CAAC,UAAU,CACb,IAAI,EAAE,sBAAsB,EAC5B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GAAI,iBAAiB,GAAG,SAAS;CAiCnD"}