@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -0,0 +1,65 @@
+// 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` 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.
+import { beforeAll, 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 { null_style, presentation_style_assignment } from "./AP214E3_2010_gen/index.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+const conwayGeom = new ConwayGeometry();
+/**
+ * Initialize the wasm.
+ */
+async function initializeWasm() {
+    await conwayGeom.initialize();
+}
+const parser = AP214StepParser.Instance;
+// Lifted from nist_stc_06_asme1_ap242-e3.stp, which produces 82 of these.
+// The surrounding ANNOTATION_PLANE is what actually got dropped in the
+// corpus: the throw escaped the styled-item extraction and was caught per
+// representation item.
+const TYPED_STYLE = `#10028 = PRESENTATION_STYLE_ASSIGNMENT((NULL_STYLE(.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 = PRESENTATION_STYLE_ASSIGNMENT((.NULL.));`;
+const STYLE_EXPRESS_ID = 10028;
+/**
+ * Parse one PRESENTATION_STYLE_ASSIGNMENT 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 presentation_style_assignment)) {
+        throw new Error("expected a presentation_style_assignment");
+    }
+    return assignment.styles;
+}
+beforeAll(async () => {
+    await initializeWasm();
+});
+describe("a typed enum in a select", () => {
+    test("NULL_STYLE(.NULL.) resolves instead of throwing", () => {
+        expect(stylesOf(TYPED_STYLE)).toEqual([null_style.NULL]);
+    });
+    test("the bare form still resolves", () => {
+        expect(stylesOf(BARE_STYLE)).toEqual([null_style.NULL]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,111 @@
+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";
+/* eslint-disable no-magic-numbers -- fixture dimensions, reified vertex
+   layout (6 floats) and 4x4 matrix element indices are all clearer as
+   literals here than as named constants. */
+/**
+ * A millimetre-declared STEP part (`SI_UNIT(.MILLI.,.METRE.)`): a tube
+ * 50 x 50 x 100 mm. Any mm fixture would do — what matters is that the
+ * declared unit is not the world unit, so the root unit-scale transform
+ * has to do real work and its direction is observable.
+ */
+const FIXTURE = "data/create-a-tube.step";
+/** Metres per millimetre — the factor a `.MILLI.` file must scale by. */
+const MM_IN_M = 0.001;
+/** The fixture's size in its own (millimetre) file coordinates. */
+const EXPECTED_FILE_SIZE_MM = [50, 50, 100];
+/** Fractional slack, covering tessellation chord error on the tube's curves. */
+const TOLERANCE = 0.02;
+let scene;
+let conwayGeometry;
+beforeAll(async () => {
+    const parser = AP214StepParser.Instance;
+    const buffer = new ParsingBuffer(fs.readFileSync(FIXTURE));
+    expect(parser.parseHeader(buffer)[1]).toBe(ParseResult.COMPLETE);
+    const [, parsed] = parser.parseDataToModel(buffer);
+    expect(parsed).not.toBe(void 0);
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+    const [result, sceneBuilder] = new AP214GeometryExtraction(conwayGeometry, parsed).extractAP214GeometryData();
+    expect(result).toBe(ExtractResult.COMPLETE);
+    scene = sceneBuilder;
+});
+/**
+ * Axis-aligned bounds of the whole scene, with each mesh's absolute
+ * transform applied — i.e. the model as the renderer sees it, which is
+ * where the root unit scale actually lands (vertices stay in file
+ * coordinates).
+ *
+ * @return The size along x, y and z.
+ */
+function worldSize() {
+    const mins = [Infinity, Infinity, Infinity];
+    const maxs = [-Infinity, -Infinity, -Infinity];
+    const wasm = conwayGeometry.wasmModule;
+    for (const [transform, , mesh] of scene.walk()) {
+        const geometry = mesh.geometry;
+        const vertexFloatCount = geometry.GetVertexDataSize();
+        // Reified layout: 6 floats per vertex, position xyz then normal xyz.
+        const vertexData = wasm.HEAPF32.subarray(geometry.GetVertexData() / 4, (geometry.GetVertexData() / 4) + vertexFloatCount);
+        for (let where = 0; where < vertexFloatCount; where += 6) {
+            const x = vertexData[where];
+            const y = vertexData[where + 1];
+            const z = vertexData[where + 2];
+            const point = transform !== void 0 ? [
+                (transform[0] * x) + (transform[4] * y) + (transform[8] * z) + transform[12],
+                (transform[1] * x) + (transform[5] * y) + (transform[9] * z) + transform[13],
+                (transform[2] * x) + (transform[6] * y) + (transform[10] * z) + transform[14],
+            ] : [x, y, z];
+            for (let axis = 0; axis < 3; ++axis) {
+                mins[axis] = Math.min(mins[axis], point[axis]);
+                maxs[axis] = Math.max(maxs[axis], point[axis]);
+            }
+        }
+    }
+    return maxs.map((max, axis) => max - mins[axis]);
+}
+describe("AP214 root unit scale", () => {
+    test("a millimetre model lands in world space in metres (issue #458)", () => {
+        const size = worldSize();
+        EXPECTED_FILE_SIZE_MM.forEach((millimetres, axis) => {
+            const expectedMetres = millimetres * MM_IN_M;
+            expect(size[axis]).toBeGreaterThan(expectedMetres * (1 - TOLERANCE));
+            expect(size[axis]).toBeLessThan(expectedMetres * (1 + TOLERANCE));
+        });
+    });
+    test("the scale is metres-per-file-unit, not its reciprocal (issue #458)", () => {
+        // The bug this pins was a sign-of-exponent error, not a missing
+        // conversion: the root transform scaled by 1/unitInM, so a millimetre
+        // model came out 1000x too LARGE rather than 1000x too small. Reading
+        // the scale straight off the absolute transform's basis keeps that
+        // direction pinned independently of how big the fixture happens to be.
+        //
+        // Measured per mesh from the basis rather than from a bounds ratio,
+        // because instance placements move parts around: a whole-scene bounds
+        // ratio starts failing on correct code the moment the fixture gains a
+        // second occurrence. Placements are rigid, so the column norm carries
+        // the unit scale alone.
+        //
+        // This expects ONE scale across the scene, which holds because the
+        // fixture is single-unit. A mixed-unit assembly is a different case —
+        // there `doTransforms` reconciles each child into its parent's unit,
+        // so a metre-declared sub-part legitimately ends up at basis norm 1.0
+        // — and swapping FIXTURE for one would need the expectation taken per
+        // representation's own declared unit rather than as a constant.
+        let meshCount = 0;
+        for (const [transform] of scene.walk()) {
+            expect(transform).toBeDefined();
+            const basisColumnLength = Math.hypot(transform[0], transform[1], transform[2]);
+            expect(basisColumnLength).toBeCloseTo(MM_IN_M, 6);
+            ++meshCount;
+        }
+        // A scene that walked nothing would pass the loop vacuously.
+        expect(meshCount).toBeGreaterThan(0);
+    });
+});

package/compiled/src/compat/web-ifc/ap214_streamed_open.test.d.ts

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

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

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

package/compiled/src/compat/web-ifc/ap214_streamed_open.test.js

@@ -0,0 +1,190 @@
+/* eslint-disable no-magic-numbers */
+// STEP demand parity phase 1: the streamed columnar open for AP214 must
+// reproduce the classic open exactly — same entities, same placed
+// instances and transforms, and byte-identical GetGeometry vertex
+// content (the served float frame must match the scene transforms; see
+// AP214ModelGeometry.add's mirror-freeze note).
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { IfcAPI } from "./ifc_api.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+// Fixtures with real served geometry (as1-assembly is structure-only —
+// zero meshes even classically; ap214-multibody-part's geometry ids
+// serve no vertex data through GetGeometry on the classic path either).
+const FIXTURES = [
+    "data/nema-23-76mm.step",
+    "data/a-gear-with-3-inch-diameter-and-20-curved-teeth.step",
+];
+let api;
+/**
+ * Capture per-entity placed instances from a model.
+ *
+ * @param modelID The open model.
+ * @return {Map} expressID -> {geometryExpressID, flatTransformation}[].
+ */
+function capture(modelID) {
+    const instances = new Map();
+    api.StreamAllMeshes(modelID, (mesh) => {
+        const list = instances.get(mesh.expressID) ?? [];
+        for (let where = 0; where < mesh.geometries.size(); ++where) {
+            const placed = mesh.geometries.get(where);
+            list.push({
+                geometryExpressID: placed.geometryExpressID,
+                flatTransformation: [...placed.flatTransformation],
+            });
+        }
+        instances.set(mesh.expressID, list);
+    });
+    return instances;
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+}, 120000);
+describe("OpenModelStreamed on AP214 STEP input", () => {
+    test.each(FIXTURES)("streamed open matches classic exactly: %s", async (fixture) => {
+        const data = new Uint8Array(fs.readFileSync(fixture));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        expect(classic.size).toBeGreaterThan(0);
+        const streamedID = await api.OpenModelStreamed(data, SETTINGS);
+        expect(streamedID).toBeGreaterThanOrEqual(0);
+        const streamed = capture(streamedID);
+        expect(streamed.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            const streamedList = streamed.get(expressID);
+            expect(streamedList).toBeDefined();
+            expect(streamedList.length).toBe(classicList.length);
+            for (let where = 0; where < classicList.length; ++where) {
+                expect(streamedList[where].geometryExpressID)
+                    .toBe(classicList[where].geometryExpressID);
+                expect(streamedList[where].flatTransformation)
+                    .toEqual(classicList[where].flatTransformation);
+            }
+        }
+        // Vertex content: the streamed open's GetGeometry must serve
+        // byte-identical floats to classic for every placed geometry.
+        const geometryIDs = new Set();
+        for (const list of classic.values()) {
+            for (const placed of list) {
+                geometryIDs.add(placed.geometryExpressID);
+            }
+        }
+        let compared = 0;
+        for (const geometryID of geometryIDs) {
+            const classicGeometry = api.GetGeometry(classicID, geometryID);
+            const streamedGeometry = api.GetGeometry(streamedID, geometryID);
+            const classicSize = classicGeometry.GetVertexDataSize();
+            if (classicSize === 0) {
+                continue;
+            }
+            expect(streamedGeometry.GetVertexDataSize()).toBe(classicSize);
+            expect(api.GetVertexArray(streamedGeometry.GetVertexData(), classicSize))
+                .toEqual(api.GetVertexArray(classicGeometry.GetVertexData(), classicSize));
+            ++compared;
+        }
+        expect(compared).toBeGreaterThan(0);
+        // No CloseModel here: closing destroys the shared wasm processor
+        // and poisons later opens (pre-existing multi-open quirk).
+    }, 240000);
+    test.each(FIXTURES)("deferred unit pump to completion matches classic exactly: %s", async (fixture) => {
+        const data = new Uint8Array(fs.readFileSync(fixture));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        expect(classic.size).toBeGreaterThan(0);
+        const deferredID = await api.OpenModelStreamed(data, { ...SETTINGS, DEFER_GEOMETRY: true });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        // Pump in deliberately small unit batches, accumulating delta
+        // emissions additively per entity.
+        const pumped = new Map();
+        let rounds = 0;
+        for (;;) {
+            const { extracted, remaining } = api.ExtractGeometryBatch(deferredID, 2, (mesh) => {
+                const list = pumped.get(mesh.expressID) ?? [];
+                for (let where = 0; where < mesh.geometries.size(); ++where) {
+                    const placed = mesh.geometries.get(where);
+                    list.push({
+                        geometryExpressID: placed.geometryExpressID,
+                        flatTransformation: [...placed.flatTransformation],
+                    });
+                }
+                pumped.set(mesh.expressID, list);
+            });
+            ++rounds;
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        expect(rounds).toBeGreaterThan(1);
+        expect(pumped.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            const pumpedList = pumped.get(expressID);
+            expect(pumpedList).toBeDefined();
+            expect(pumpedList.length).toBe(classicList.length);
+            // Instance sets match (order may differ across unit batches):
+            // every classic instance has an exactly-matching pumped one.
+            const unmatched = pumpedList.map((entry) => entry);
+            for (const reference of classicList) {
+                const matchIndex = unmatched.findIndex((candidate) => candidate.geometryExpressID === reference.geometryExpressID &&
+                    candidate.flatTransformation.every((value, where) => Math.abs(value - reference.flatTransformation[where]) < 1e-9));
+                expect(matchIndex).toBeGreaterThanOrEqual(0);
+                unmatched.splice(matchIndex, 1);
+            }
+        }
+        // No CloseModel: closing destroys the shared wasm processor and
+        // degrades later opens (pre-existing multi-open quirk).
+    }, 240000);
+    test("ON_PREVIEW_MESH emits classic-parity payloads for STEP (phase 3)", async () => {
+        // The gear parses in one cooperative slice, so the timer-driven
+        // channel never fires during a real open here — drive the channel
+        // directly over a finished sink (prefix == whole file), like the
+        // IFC channel test: a full drain must reproduce the classic
+        // instance set with the AP214 capture math (bare composition).
+        const fs2 = await import("fs");
+        const { ConwayGeometry } = await import("../../../dependencies/conway-geom/index.js");
+        const { buildIndexStreaming } = await import("../../step/parsing/streaming_index_builder.js");
+        const { ColumnarIndexSink } = await import("../../step/parsing/columnar_index.js");
+        const { BufferByteSource } = await import("../../step/parsing/byte_source.js");
+        const AP214StepParser = (await import("../../AP214E3_2010/ap214_step_parser.js")).default;
+        const { ap214PreviewAdapter, StreamedPreviewChannel } = await import("./streamed_preview_channel.js");
+        const data = new Uint8Array(fs2.readFileSync(FIXTURES[1]));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        let classicTotal = 0;
+        for (const list of classic.values()) {
+            classicTotal += list.length;
+        }
+        expect(classicTotal).toBeGreaterThan(0);
+        const conwayGeometry = new ConwayGeometry();
+        expect(await conwayGeometry.initialize()).toBe(true);
+        const sink = new ColumnarIndexSink();
+        const { result } = buildIndexStreaming(new BufferByteSource(data), AP214StepParser.Instance, 1024 * 1024, void 0, sink);
+        expect(result).toBe(0);
+        const payloads = [];
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, sink, ap214PreviewAdapter(), true, (mesh) => payloads.push(mesh), void 0, void 0, 1);
+        channel.drainForTest();
+        expect(payloads.length).toBe(classicTotal);
+        for (const payload of payloads) {
+            const candidates = classic.get(payload.expressID);
+            expect(candidates).toBeDefined();
+            const matchIndex = candidates.findIndex((candidate) => candidate.geometryExpressID === payload.geometryExpressID &&
+                candidate.flatTransformation.every((value, where) => Math.abs(value - payload.flatTransformation[where]) < 0.000001));
+            expect(matchIndex).toBeGreaterThanOrEqual(0);
+        }
+        const carriers = payloads.filter((payload) => payload.vertexData !== void 0);
+        expect(carriers.length).toBeGreaterThan(0);
+    }, 240000);
+    test("StreamAllMeshes on a deferred STEP model drains the pump and matches classic", async () => {
+        const data = new Uint8Array(fs.readFileSync(FIXTURES[0]));
+        const classicID = api.OpenModel(data, SETTINGS);
+        const classic = capture(classicID);
+        const deferredID = await api.OpenModelStreamed(data, { ...SETTINGS, DEFER_GEOMETRY: true });
+        // No pump calls at all — the whole-model consumer must still get
+        // the complete mesh set (the proxy drains internally).
+        const drained = capture(deferredID);
+        expect(drained.size).toBe(classic.size);
+        for (const [expressID, classicList] of classic) {
+            expect(drained.get(expressID)?.length).toBe(classicList.length);
+        }
+    }, 240000);
+});

package/compiled/src/compat/web-ifc/coordination_export_order.test.d.ts

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

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

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

package/compiled/src/compat/web-ifc/coordination_export_order.test.js

@@ -0,0 +1,110 @@
+/* eslint-disable no-magic-numbers */
+// Export-order independence of the COORDINATE_TO_ORIGIN frame (Share#1749).
+//
+// The recentre anchors on the first geometry the walk reaches, which is
+// whichever element the file happens to declare first. Unsnapped, that
+// makes a model's rendered position a function of its element order:
+// Share shipped the Bldrs logo as both `index.ifc` and `index.step`, and
+// the STEP rendered 76m off the IFC because the two files disagree about
+// which block comes first. Every camera permalink spanning the pair was
+// wrong, and auto-framing hid it — the models look identical until a
+// `#c:` camera pins them.
+//
+// This drives the same surface Share does (the compat IfcAPI, not the
+// CLI's native writer, which has its own recentre convention) and pins
+// the properties the snap has to hold together: a near-origin model
+// keeps the coordinates its file authored — which is what makes two
+// exports of one object coincide — a georeferenced model still
+// recentres, and the classic and streamed opens agree.
+//
+// Not covered here: the AP214 arm. Its placements come back at the
+// origin with the geometry carrying the world transform, so neither
+// placement bounds nor a fixture pair in two element orders reproduces
+// the defect through this surface; the cross-format claim is pinned
+// Share-side instead (`src/Containers/indexStepLogo.spec.ts`, which
+// compares the rendered bounds of `index.ifc` and `index.step`).
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { LARGE_COORDINATE_BUDGET_M, COORDINATION_SNAP_M } from "./coordination_f64.js";
+import { IfcAPI } from "./ifc_api.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+let api;
+let local;
+let georeferenced;
+/**
+ * World-space bounds of every placed geometry in a model, as the
+ * consumer sees them: the placement translation is what Share stamps
+ * onto its instances.
+ *
+ * @param modelID An open model.
+ * @return {{min: number[], max: number[]}} Translation bounds.
+ */
+function placementBounds(modelID) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    api.StreamAllMeshes(modelID, (mesh) => {
+        for (let where = 0; where < mesh.geometries.size(); ++where) {
+            const t = mesh.geometries.get(where).flatTransformation;
+            for (let axis = 0; axis < 3; ++axis) {
+                min[axis] = Math.min(min[axis], t[12 + axis]);
+                max[axis] = Math.max(max[axis], t[12 + axis]);
+            }
+        }
+    });
+    return { min, max };
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+    local = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    georeferenced = new Uint8Array(fs.readFileSync("data/index_georeferenced.ifc"));
+}, 120000);
+describe("COORDINATE_TO_ORIGIN export-order independence (Share#1749)", () => {
+    test("a near-origin model keeps its authored coordinates", async () => {
+        const modelID = await api.OpenModel(local, { ...SETTINGS });
+        const { min, max } = placementBounds(modelID);
+        expect(Number.isFinite(min[0])).toBe(true);
+        // The logo's first-declared block sits at x=76, so the unsnapped
+        // frame used to drag the whole model 76m negative. Snapped, the
+        // anchor lands in the origin cell and the model stays where the file
+        // put it — which is what makes a second export of the same object
+        // coincide with it regardless of element order.
+        expect(Math.max(...min.map(Math.abs), ...max.map(Math.abs)))
+            .toBeLessThan(COORDINATION_SNAP_M);
+        expect(min[0]).toBeGreaterThanOrEqual(0);
+        api.CloseModel(modelID);
+    }, 120000);
+    test("a georeferenced model still recentres, inside the budget", async () => {
+        const modelID = await api.OpenModel(georeferenced, { ...SETTINGS });
+        const { min, max } = placementBounds(modelID);
+        // Snapping costs at most half a cell on top of the model's own
+        // extent; the budget is the threshold above which float32 jitter
+        // becomes visible (Share#1631).
+        expect(Math.max(...min.map(Math.abs), ...max.map(Math.abs)))
+            .toBeLessThan(LARGE_COORDINATE_BUDGET_M);
+        // The applied-frame report (Share#1634) is not asserted here: only
+        // the deferred pump records it, and
+        // `ifc_api_preview_coordination.test.ts` already covers that path.
+        api.CloseModel(modelID);
+    }, 120000);
+    test("the classic and streamed opens agree on the frame", async () => {
+        // Both paths derive through deriveCoordinationF64, so the snap has
+        // to leave them identical — otherwise one model renders in two
+        // places depending on which open Share happened to take. Compared
+        // through the emitted placements rather than
+        // GetAppliedCoordinationMatrix, which only the deferred pump fills
+        // in: on these two opens it reports the identity contract for both,
+        // so comparing it would pass no matter what the frames did.
+        const classicID = await api.OpenModel(georeferenced, { ...SETTINGS });
+        const classic = placementBounds(classicID);
+        api.CloseModel(classicID);
+        const streamedID = await api.OpenModelStreamed(georeferenced, { ...SETTINGS });
+        const streamed = placementBounds(streamedID);
+        api.CloseModel(streamedID);
+        expect(Number.isFinite(classic.min[0])).toBe(true);
+        for (let axis = 0; axis < 3; ++axis) {
+            expect(streamed.min[axis]).toBeCloseTo(classic.min[axis], 6);
+            expect(streamed.max[axis]).toBeCloseTo(classic.max[axis], 6);
+        }
+    }, 120000);
+});