@bldrs-ai/conway 1.488.1413 → 1.494.1415

package/compiled/src/ifc/ifc_typed_select_enum.test.js

@@ -0,0 +1,60 @@
+// A select member whose type is an enum may be written bare or in its typed
+// form - `.NULL.` or `NULL_STYLE(.NULL.)`. Inside a SELECT the typed form is
+// how a reader tells which member the value is, so exporters use it, and the
+// NIST AP242 set uses it throughout.
+//
+// Reading the typed form used to throw 'Value in select must be populated',
+// because the generated getter's enum fallback is a bare parse starting at
+// the cursor and the wrapper made it fail. Entity-valued members were never
+// affected - the parser indexes an inline TYPENAME(...) entity and
+// extractBufferReference resolves it by address - so this was specific to
+// enum members, and `null_style` / `IfcNullStyle` is the only enum inside a
+// select in either schema. It accounted for 274 of the public regression
+// baseline's error rows, every one of them a lost styled item. See
+// bldrs-ai/conway#489.
+//
+// Both schemas are covered: the fix is emitted by the generator at two sites,
+// one per schema, and a regeneration that reverted either would otherwise
+// ship green. scripts/code-gen.cjs clones the generator unpinned, so that is
+// not a hypothetical.
+//
+// Parser-only, so no geometry wasm is initialized here - importing it would
+// make this fail at import in a checkout without the Dist built, for a
+// dependency it never uses.
+import { describe, expect, test } from "@jest/globals";
+import IfcStepParser from "./ifc_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { IfcNullStyle, IfcPresentationStyleAssignment } from "./ifc4_gen/index.js";
+const parser = IfcStepParser.Instance;
+const TYPED_STYLE = `#10028 = IFCPRESENTATIONSTYLEASSIGNMENT((IFCNULLSTYLE(.NULL.)));`;
+// The same value written bare, which always worked. Kept alongside so a
+// change that fixes one by breaking the other cannot pass.
+const BARE_STYLE = `#10028 = IFCPRESENTATIONSTYLEASSIGNMENT((.NULL.));`;
+const STYLE_EXPRESS_ID = 10028;
+/**
+ * Parse one IFCPRESENTATIONSTYLEASSIGNMENT and read back its styles.
+ *
+ * @param source The STEP text to parse.
+ * @return {Array<unknown>} The resolved styles array.
+ */
+function stylesOf(source) {
+    const [result, model] = parser.parseDataToModel(new ParsingBuffer(new TextEncoder().encode(source)));
+    if (model === void 0 ||
+        (result !== ParseResult.COMPLETE && result !== ParseResult.INCOMPLETE)) {
+        throw new Error(`parse failed with result ${result}`);
+    }
+    const assignment = model.getElementByExpressID(STYLE_EXPRESS_ID);
+    if (!(assignment instanceof IfcPresentationStyleAssignment)) {
+        throw new Error("expected an IfcPresentationStyleAssignment");
+    }
+    return assignment.Styles;
+}
+describe("a typed enum in an IFC select", () => {
+    test("IFCNULLSTYLE(.NULL.) resolves instead of throwing", () => {
+        expect(stylesOf(TYPED_STYLE)).toEqual([IfcNullStyle.NULL]);
+    });
+    test("the bare form still resolves", () => {
+        expect(stylesOf(BARE_STYLE)).toEqual([IfcNullStyle.NULL]);
+    });
+});

package/compiled/src/step/parsing/step_deserialization_functions.d.ts

@@ -118,6 +118,35 @@ export declare function stepExtractArrayToken(buffer: Uint8Array, cursor: number
  * @return {IterableIterator} Lazy iterator to extract value.
  */
 export declare function stepExtractArray(buffer: Uint8Array, cursor: number, endCursor: number): IterableIterator<number>;
+/**
+ * Step past a `TYPENAME(` wrapper to the value inside it, when the value at
+ * the cursor is written in its typed form and the type name matches.
+ *
+ * A select member may be written either bare or typed — `.NULL.` or
+ * `NULL_STYLE(.NULL.)` — and inside a SELECT the typed form is how a reader
+ * tells which member it is, so exporters legitimately use it. Entity-valued
+ * members already handle both, because the parser indexes an inline
+ * `TYPENAME(...)` entity and `extractBufferReference` resolves it by address.
+ * A member whose type is an enum has no entity to index, so its deserializer
+ * is a bare parse starting at the cursor, and the wrapper makes it fail.
+ * That cost 274 of the public regression baseline's error rows — every
+ * `PRESENTATION_STYLE_ASSIGNMENT((NULL_STYLE(.NULL.)))` in the corpus threw
+ * and lost its styled item. See bldrs-ai/conway#489.
+ *
+ * The type name is verified rather than skipped past, so this accepts only
+ * the value's own typed form: a mismatched wrapper stays a type error
+ * instead of being silently read as the member it isn't.
+ *
+ * @param buffer The buffer to read from.
+ * @param cursor The position the value starts at.
+ * @param endCursor The last position accessible for this read in the buffer.
+ * @param typeName The expected STEP type name of the wrapper, upper case —
+ * StepEntityIdentifierParser matches `[A-Z][A-Z0-9_]*`, so a lower-case
+ * spelling is not an identifier here and never reaches the comparison.
+ * @return {number} The position just inside the wrapper's parenthesis, or
+ * `cursor` unchanged when the value is not this type's typed form.
+ */
+export declare function stepEnterTypedValue(buffer: Uint8Array, cursor: number, endCursor: number, typeName: string): number;
 /**
  * Extracts an inline element and returns its cursor, or none if it can't be found.
  *

package/compiled/src/step/parsing/step_deserialization_functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step_deserialization_functions.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/step_deserialization_functions.ts"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAGD;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,YAAY,EAAE,CAAC,GAAI,CAAC,CAE9E;AAGD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAI,MAAM,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAI,MAAM,CAEvE;AAGD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAUvC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,GAAG,SAAS,CAM1C;AAGD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,OAAO,GAAG,IAAI,GAAG,SAAS,CAwBlD;AAGD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,OAAO,GAAG,SAAS,CAgB3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAK,MAAM,CA2E/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,CA0B9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,CA0C9B;AAED;;;;;;;;;GASG;AACH,wBAAiB,gBAAgB,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,gBAAgB,CAAE,MAAM,CAAE,CAkGlD;AAGD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,GAAG,SAAS,CA4C1C;AAID;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAK,MAAM,GAAG,SAAS,CAsC3C;AAED,QAAA,MAAM,eAAe,8JAAkC,CAAA;AAEvD,OAAO,EAAE,eAAe,EAAE,CAAA;AAE1B,QAAA,MAAM,iBAAiB,iGAAoC,CAAA;AAE3D,OAAO,EAAE,iBAAiB,EAAE,CAAA;AAE5B,QAAA,MAAM,iBAAiB,4FAAiC,CAAA;AAExD,OAAO,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"step_deserialization_functions.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/step_deserialization_functions.ts"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAGD;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,YAAY,EAAE,CAAC,GAAI,CAAC,CAE9E;AAGD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAI,MAAM,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAE,CAAC,EAAI,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAI,MAAM,CAEvE;AAGD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAUvC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,GAAG,SAAS,CAM1C;AAGD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,OAAO,GAAG,IAAI,GAAG,SAAS,CAwBlD;AAGD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,OAAO,GAAG,SAAS,CAgB3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAK,MAAM,CA2E/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,CA0B9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,CA0C9B;AAED;;;;;;;;;GASG;AACH,wBAAiB,gBAAgB,CAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,gBAAgB,CAAE,MAAM,CAAE,CAkGlD;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GAAI,MAAM,CAqB7B;AAGD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAI,MAAM,GAAG,SAAS,CA4C1C;AAID;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAAK,MAAM,GAAG,SAAS,CAsC3C;AAED,QAAA,MAAM,eAAe,8JAAkC,CAAA;AAEvD,OAAO,EAAE,eAAe,EAAE,CAAA;AAE1B,QAAA,MAAM,iBAAiB,iGAAoC,CAAA;AAE3D,OAAO,EAAE,iBAAiB,EAAE,CAAA;AAE5B,QAAA,MAAM,iBAAiB,4FAAiC,CAAA;AAExD,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/compiled/src/step/parsing/step_deserialization_functions.js

@@ -367,6 +367,51 @@ export function* stepExtractArray(buffer, cursor, endCursor) {
         throw new Error("Unterminated array");
     }
 }
+/**
+ * Step past a `TYPENAME(` wrapper to the value inside it, when the value at
+ * the cursor is written in its typed form and the type name matches.
+ *
+ * A select member may be written either bare or typed — `.NULL.` or
+ * `NULL_STYLE(.NULL.)` — and inside a SELECT the typed form is how a reader
+ * tells which member it is, so exporters legitimately use it. Entity-valued
+ * members already handle both, because the parser indexes an inline
+ * `TYPENAME(...)` entity and `extractBufferReference` resolves it by address.
+ * A member whose type is an enum has no entity to index, so its deserializer
+ * is a bare parse starting at the cursor, and the wrapper makes it fail.
+ * That cost 274 of the public regression baseline's error rows — every
+ * `PRESENTATION_STYLE_ASSIGNMENT((NULL_STYLE(.NULL.)))` in the corpus threw
+ * and lost its styled item. See bldrs-ai/conway#489.
+ *
+ * The type name is verified rather than skipped past, so this accepts only
+ * the value's own typed form: a mismatched wrapper stays a type error
+ * instead of being silently read as the member it isn't.
+ *
+ * @param buffer The buffer to read from.
+ * @param cursor The position the value starts at.
+ * @param endCursor The last position accessible for this read in the buffer.
+ * @param typeName The expected STEP type name of the wrapper, upper case —
+ * StepEntityIdentifierParser matches `[A-Z][A-Z0-9_]*`, so a lower-case
+ * spelling is not an identifier here and never reaches the comparison.
+ * @return {number} The position just inside the wrapper's parenthesis, or
+ * `cursor` unchanged when the value is not this type's typed form.
+ */
+export function stepEnterTypedValue(buffer, cursor, endCursor, typeName) {
+    const identifierEnd = identifierParser.match(buffer, cursor, endCursor);
+    if (identifierEnd === void 0 || (identifierEnd - cursor) !== typeName.length) {
+        return cursor;
+    }
+    for (let where = 0; where < typeName.length; ++where) {
+        if (buffer[cursor + where] !== typeName.charCodeAt(where)) {
+            return cursor;
+        }
+    }
+    // Delegate the rest to the inline-element reader rather than repeating its
+    // identifier/whitespace/comment/paren walk. Sharing it is not just less
+    // code: entity-valued select members reach their value through that exact
+    // function, so a divergence here would mean the two kinds of member in the
+    // SAME select disagreed about where a typed value begins.
+    return stepExtractInlineElemement(buffer, cursor, endCursor) ?? cursor;
+}
 /**
  * Extracts an inline element and returns its cursor, or none if it can't be found.
  *

package/compiled/src/step/parsing/step_deserialization_functions.test.js

@@ -7,7 +7,7 @@
 // unreachable after spill + release, where before it was retained via
 // Context[parsingBufferReusable] → ParsingBuffer.buffer).
 import { describe, expect, test } from "@jest/globals";
-import { releaseScratchParsingBuffer, stepExtractNumber, } from "./step_deserialization_functions.js";
+import { releaseScratchParsingBuffer, stepEnterTypedValue, stepExtractNumber, } from "./step_deserialization_functions.js";
 const REAL_VALUE = 42.5;
 const INT_VALUE = 7;
 describe("releaseScratchParsingBuffer", () => {
@@ -25,3 +25,61 @@ describe("releaseScratchParsingBuffer", () => {
         expect(stepExtractNumber(bytes, 0, bytes.length)).toBe(REAL_VALUE);
     });
 });
+describe("stepEnterTypedValue", () => {
+    /**
+     * Encode and enter, returning both the cursor and what it points at, so a
+     * failed expectation says which byte the function landed on.
+     *
+     * @param text The STEP text to read from position 0.
+     * @param typeName The expected wrapper type name.
+     * @return {[number, string]} The returned cursor and the character there.
+     */
+    const enter = (text, typeName) => {
+        const bytes = new TextEncoder().encode(text);
+        const cursor = stepEnterTypedValue(bytes, 0, bytes.length, typeName);
+        return [cursor, text[cursor] ?? ""];
+    };
+    test("enters a matching wrapper, landing on the value", () => {
+        // The case from bldrs-ai/conway#489: 274 occurrences in the public
+        // regression baseline, every one of them throwing and losing its
+        // styled item because the enum parse started on the 'N'.
+        // Positions derived rather than written out, so the expectation says
+        // "just past the wrapper" rather than asserting an opaque index.
+        expect(enter("NULL_STYLE(.NULL.)", "NULL_STYLE"))
+            .toEqual(["NULL_STYLE(".length, "."]);
+        expect(enter("IFCNULLSTYLE(.NULL.)", "IFCNULLSTYLE"))
+            .toEqual(["IFCNULLSTYLE(".length, "."]);
+    });
+    test("leaves a bare value alone", () => {
+        // Both forms are legal for a select member, so entering must be a no-op
+        // on the bare one rather than a precondition.
+        expect(enter(".NULL.", "NULL_STYLE")).toEqual([0, "."]);
+    });
+    test("does not treat a lower-case spelling as the type name", () => {
+        // Not a policy choice here: StepEntityIdentifierParser matches
+        // `[A-Z][A-Z0-9_]*`, so a lower-case wrapper is not an identifier at all
+        // and the value is left to be read bare (where it then fails as the
+        // malformed input it is).
+        expect(enter("null_style(.NULL.)", "NULL_STYLE")).toEqual([0, "n"]);
+    });
+    test("skips whitespace and comments before and after the paren", () => {
+        const spaced = "NULL_STYLE /* c */ ( /* d */ .NULL.)";
+        expect(enter(spaced, "NULL_STYLE")).toEqual([spaced.indexOf(".NULL."), "."]);
+    });
+    test("refuses a wrapper that is not this type", () => {
+        // The point of verifying the name rather than skipping any identifier:
+        // a mismatched wrapper stays a type error instead of being silently
+        // read as the member it is not.
+        expect(enter("SOME_OTHER_TYPE(.NULL.)", "NULL_STYLE")).toEqual([0, "S"]);
+        // A prefix must not match either - length is checked before the bytes.
+        expect(enter("NULL_STYLE_EXTRA(.NULL.)", "NULL_STYLE")).toEqual([0, "N"]);
+    });
+    test("refuses an identifier with no parenthesis", () => {
+        expect(enter("NULL_STYLE", "NULL_STYLE")).toEqual([0, "N"]);
+        expect(enter("NULL_STYLE.NULL.", "NULL_STYLE")).toEqual([0, "N"]);
+    });
+    test("refuses a reference or a bare number", () => {
+        expect(enter("#4085", "NULL_STYLE")).toEqual([0, "#"]);
+        expect(enter("0.7", "NULL_STYLE")).toEqual([0, "0"]);
+    });
+});

package/compiled/src/version/version.js

@@ -5,5 +5,5 @@
 // only the first segment (major) is meaningful and is the one CI carries forward.
 // Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
 // statistics.ts all match `v\d+\.\d+\.\d+`.
-const versionString = 'Conway v1.488.1413';
+const versionString = 'Conway v1.494.1415';
 export { versionString };