@bldrs-ai/conway 1.543.1513 → 1.548.1514

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.543.1513";
+var versionString = "Conway v1.548.1514";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.543.1513";
+var versionString = "Conway v1.548.1514";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

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

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.543.1513";
+var versionString = "Conway v1.548.1514";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.543.1513";
+var versionString = "Conway v1.548.1514";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/scripts/bless_perf_snapshot.test.d.ts

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

package/compiled/src/scripts/bless_perf_snapshot.test.d.ts.map

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

package/compiled/src/scripts/bless_perf_snapshot.test.js

@@ -0,0 +1,278 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, expect, test, beforeEach, afterEach } from '@jest/globals';
+import { createRequire } from 'module';
+/**
+ * The rc-regression bless path's perf snapshot (scripts/bless_perf_snapshot.cjs).
+ *
+ * The `rebless` job measures the full corpus with
+ * `ifc_regression_batch_main --perf`, whose 8-column perf.csv is a different
+ * file from the 15-column `performance-detail.csv` the committed benchmark
+ * snapshots use. This pins the mapping between them — the shape a delta and
+ * GitHub's CSV viewer both depend on — and the choice of predecessor to diff
+ * against.
+ */
+const require_ = createRequire(import.meta.url);
+// Resolved from the repo root: the test runs from compiled/src/scripts, and
+// scripts/ is not part of the tsc build. Jest's rootDir is the repo root.
+const { DETAIL_COLUMNS, findPreviousSnapshot, isChronologicalDelta, removeStaleDeltas, writeDetailCsv, versionCompare, } = require_(path.resolve(process.cwd(), 'scripts/bless_perf_snapshot.cjs'));
+const { parseCsv } = require_(path.resolve(process.cwd(), 'scripts/csv_rfc4180.cjs'));
+let workDir;
+beforeEach(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bless-perf-'));
+});
+afterEach(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+describe('writeDetailCsv', () => {
+    test('maps perf.csv onto the 15-column convention, N/A for unmeasured', () => {
+        const out = path.join(workDir, 'performance-detail.csv');
+        writeDetailCsv([{
+                file: 'Snowdon Towers Sample Architectural_IFC4.ifc',
+                status: 'OK',
+                parseTimeMs: '1200',
+                geometryTimeMs: '5400',
+                totalTimeMs: '6600',
+                rssMb: '812.50',
+                heapUsedMb: '410.25',
+                heapTotalMb: '450.00',
+            }], out, 'conway1.543.1513-ci', '20260821221710');
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        expect(records[0]).toEqual(DETAIL_COLUMNS);
+        expect(records).toHaveLength(2);
+        const row = records[1];
+        expect(row).toHaveLength(DETAIL_COLUMNS.length);
+        /**
+         * Read one column of the written row.
+         *
+         * @param column Column name.
+         * @return The cell value.
+         */
+        const cell = (column) => row[DETAIL_COLUMNS.indexOf(column)];
+        expect(cell('engine')).toBe('conway1.543.1513-ci');
+        expect(cell('loadStatus')).toBe('OK');
+        expect(cell('parseTimeMs')).toBe('1200');
+        expect(cell('geometryTimeMs')).toBe('5400');
+        expect(cell('totalTimeMs')).toBe('6600');
+        expect(cell('rssMb')).toBe('812.50');
+        // The committed snapshots URL-encode the filename and the delta joins on
+        // it, so an unencoded name would simply fail to match the baseline row.
+        expect(cell('filename'))
+            .toBe('Snowdon%20Towers%20Sample%20Architectural_IFC4.ifc');
+        // perf.csv does not carry these; they stay as placeholders rather than
+        // being dropped, so the row keeps its 15-column shape.
+        for (const column of ['schemaVersion', 'geometryMemoryMb', 'preprocessorVersion',
+            'originatingSystem']) {
+            expect(cell(column)).toBe('N/A');
+        }
+    });
+    test('carries a FAIL row through instead of dropping it', () => {
+        const out = path.join(workDir, 'fail.csv');
+        writeDetailCsv([{
+                file: 'broken.ifc', status: 'FAIL', parseTimeMs: '90',
+                geometryTimeMs: '0', totalTimeMs: '90', rssMb: '', heapUsedMb: '',
+                heapTotalMb: '',
+            }], out, 'conway1.543.1513-ci', '20260821221710');
+        const row = parseCsv(fs.readFileSync(out, 'utf8'))[1];
+        expect(row[DETAIL_COLUMNS.indexOf('loadStatus')]).toBe('FAIL');
+        // An empty measurement becomes N/A, which gen_delta_csv.cjs reads as 0
+        // rather than NaN.
+        expect(row[DETAIL_COLUMNS.indexOf('rssMb')]).toBe('N/A');
+    });
+});
+describe('findPreviousSnapshot', () => {
+    /**
+     * Create a benchmarks/ directory containing the named snapshot dirs, each
+     * with a performance-detail.csv.
+     *
+     * @param names Snapshot directory names.
+     * @param withoutCsv Names to create empty, without a CSV.
+     * @return Path to the benchmarks directory.
+     */
+    function makeBenchmarks(names, withoutCsv = []) {
+        const benchmarks = path.join(workDir, 'benchmarks');
+        for (const name of [...names, ...withoutCsv]) {
+            fs.mkdirSync(path.join(benchmarks, name), { recursive: true });
+        }
+        for (const name of names) {
+            fs.writeFileSync(path.join(benchmarks, name, 'performance-detail.csv'), 'header\n');
+        }
+        return benchmarks;
+    }
+    test('picks the highest version, comparing numerically not lexically', () => {
+        // 0.9.789 sorts after 0.23.940 as a string; the corpus has both.
+        const benchmarks = makeBenchmarks([
+            'conway0.9.789_test-models',
+            'conway0.23.940-ci_test-models',
+            'conway1.451.1357-ci_test-models',
+        ]);
+        const previous = findPreviousSnapshot(benchmarks, 'conway1.543.1513-ci_test-models', '1.543.1513');
+        expect(previous).not.toBeNull();
+        expect(previous.name).toBe('conway1.451.1357-ci_test-models');
+        // engine1 half of the delta filename, suffix included.
+        expect(previous.engine).toBe('conway1.451.1357-ci');
+    });
+    test('excludes the directory this run is writing', () => {
+        // Re-running the same rc must not diff a snapshot against itself.
+        const benchmarks = makeBenchmarks([
+            'conway1.451.1357-ci_test-models',
+            'conway1.543.1513-ci_test-models',
+        ]);
+        const previous = findPreviousSnapshot(benchmarks, 'conway1.543.1513-ci_test-models', '1.543.1513');
+        expect(previous.name).toBe('conway1.451.1357-ci_test-models');
+    });
+    test('ignores webifc dirs and dirs with no performance-detail.csv', () => {
+        const benchmarks = makeBenchmarks(['conway0.23.940_test-models'], ['webifc0.0.67_test-models', 'conway9.9.9-ci_test-models']);
+        const previous = findPreviousSnapshot(benchmarks, 'conway1.543.1513-ci_test-models', '1.543.1513');
+        expect(previous.name).toBe('conway0.23.940_test-models');
+    });
+    test('never selects a snapshot NEWER than the version being blessed', () => {
+        // Re-running an older rc- tag after a newer release has been blessed. An
+        // unbounded maximum picks conway1.600.1600-ci and writes
+        // `conway1.600.1600-ci_1.543.1513_delta.csv` into the OLDER release's
+        // directory — a delta claiming it changed relative to its own future.
+        const benchmarks = makeBenchmarks([
+            'conway1.451.1357-ci_test-models',
+            'conway1.543.1513-ci_test-models',
+            'conway1.600.1600-ci_test-models',
+        ]);
+        const previous = findPreviousSnapshot(benchmarks, 'conway1.543.1513-ci_test-models', '1.543.1513');
+        expect(previous.name).toBe('conway1.451.1357-ci_test-models');
+    });
+    test('bounds strictly below, so an equal version is not a predecessor', () => {
+        // The same release under a different directory name (a different harness,
+        // say) is not its own predecessor.
+        const benchmarks = makeBenchmarks([
+            'conway1.543.1513_test-models',
+            'conway1.543.1513-ci_test-models',
+        ]);
+        const previous = findPreviousSnapshot(benchmarks, 'conway1.543.1513-ci_test-models', '1.543.1513');
+        expect(previous).toBeNull();
+    });
+    test('returns null rather than reaching upward when nothing precedes', () => {
+        // The first blessed release in a repo. No delta is the correct outcome;
+        // silently picking the nearest snapshot in either direction is not.
+        const benchmarks = makeBenchmarks(['conway1.600.1600-ci_test-models']);
+        expect(findPreviousSnapshot(benchmarks, 'conway1.451.1357-ci_test-models', '1.451.1357')).toBeNull();
+    });
+    test('bounds numerically, not lexicographically', () => {
+        // Both of these directories really exist in test-models/benchmarks, and
+        // they are conway#533's trap: 0.23.940 is NEWER than 0.9.789 by number but
+        // sorts BELOW it as a string ('2' < '9' at the third character). A string
+        // bound therefore fails to exclude it, and since it is the numeric maximum
+        // it gets picked — handing the older release a delta against its future,
+        // which is the whole bug this bound exists to stop.
+        const benchmarks = makeBenchmarks([
+            'conway0.8.782_test-models',
+            'conway0.23.940_test-models',
+        ]);
+        const previous = findPreviousSnapshot(benchmarks, 'conway0.9.789_test-models', '0.9.789');
+        expect(previous.name).toBe('conway0.8.782_test-models');
+    });
+    test('returns null when there is no prior snapshot', () => {
+        expect(findPreviousSnapshot(path.join(workDir, 'nope'), 'x', '1.0.0'))
+            .toBeNull();
+        expect(findPreviousSnapshot(makeBenchmarks([]), 'x', '1.0.0')).toBeNull();
+    });
+});
+describe('versionCompare', () => {
+    test('orders by numeric component, not string order', () => {
+        expect(versionCompare('0.9.789', '0.23.940')).toBeLessThan(0);
+        expect(versionCompare('1.543.1513', '1.451.1357')).toBeGreaterThan(0);
+        expect(versionCompare('1.0.0', '1.0.0')).toBe(0);
+    });
+});
+describe('removeStaleDeltas', () => {
+    /** Everything a real release snapshot directory holds today. */
+    const RELEASE_DIR_CONTENTS = [
+        '00-command.log.txt',
+        '00-rendering-server.log.txt',
+        'README.md',
+        'conway0.22.921_0.23.940_delta.csv',
+        'index.html',
+        'performance-detail.csv',
+        'performance.csv',
+        'performance.err.txt',
+        'webifc0.0.56_conway0.23.940_delta.csv',
+        'webifc0.0.67_conway0.23.940_delta.csv',
+    ];
+    /**
+     * Populate a snapshot directory with the given entry names.
+     *
+     * @param names File names to create.
+     * @return The directory path.
+     */
+    function makeReleaseDir(names) {
+        const dir = path.join(workDir, 'conway0.23.940_test-models');
+        fs.mkdirSync(dir, { recursive: true });
+        for (const name of names) {
+            fs.writeFileSync(path.join(dir, name), 'x');
+        }
+        return dir;
+    }
+    test('removes only this release chronological delta', () => {
+        // The exact contents of benchmarks/conway0.23.940_test-models/, which
+        // legitimately carries one chronological delta AND two cross-engine ones.
+        const dir = makeReleaseDir(RELEASE_DIR_CONTENTS);
+        const removed = removeStaleDeltas(dir, '0.23.940');
+        expect(removed).toEqual(['conway0.22.921_0.23.940_delta.csv']);
+        expect(fs.readdirSync(dir).sort()).toEqual(RELEASE_DIR_CONTENTS
+            .filter((n) => n !== 'conway0.22.921_0.23.940_delta.csv').sort());
+    });
+    test('leaves the cross-engine deltas alone — they are a different comparison', () => {
+        const dir = makeReleaseDir(RELEASE_DIR_CONTENTS);
+        removeStaleDeltas(dir, '0.23.940');
+        expect(fs.existsSync(path.join(dir, 'webifc0.0.56_conway0.23.940_delta.csv')))
+            .toBe(true);
+        expect(fs.existsSync(path.join(dir, 'webifc0.0.67_conway0.23.940_delta.csv')))
+            .toBe(true);
+    });
+    test('never touches the data files or the README', () => {
+        const dir = makeReleaseDir(RELEASE_DIR_CONTENTS);
+        removeStaleDeltas(dir, '0.23.940');
+        for (const kept of ['performance-detail.csv', 'performance.csv',
+            'performance.err.txt', 'README.md', 'index.html',
+            '00-command.log.txt', '00-rendering-server.log.txt']) {
+            expect(fs.existsSync(path.join(dir, kept))).toBe(true);
+        }
+    });
+    test('clears a delta whose predecessor changed, so only one survives', () => {
+        // The case codex found: an already-blessed rc re-run after an older
+        // snapshot was backfilled picks a different predecessor and writes a
+        // differently NAMED file, leaving two deltas against different
+        // predecessors in one directory with the README naming only one.
+        const dir = makeReleaseDir([
+            'performance-detail.csv',
+            'conway0.21.915_0.23.940_delta.csv',
+        ]);
+        const removed = removeStaleDeltas(dir, '0.23.940');
+        expect(removed).toEqual(['conway0.21.915_0.23.940_delta.csv']);
+        expect(fs.readdirSync(dir)).toEqual(['performance-detail.csv']);
+    });
+    test('does not remove another release delta that happens to be present', () => {
+        const dir = makeReleaseDir([
+            'performance-detail.csv',
+            'conway0.22.921_0.23.940_delta.csv',
+        ]);
+        expect(removeStaleDeltas(dir, '1.543.1513')).toEqual([]);
+        expect(fs.existsSync(path.join(dir, 'conway0.22.921_0.23.940_delta.csv')))
+            .toBe(true);
+    });
+});
+describe('isChronologicalDelta', () => {
+    test('matches the naming convention and nothing else', () => {
+        expect(isChronologicalDelta('conway0.22.921_0.23.940_delta.csv', '0.23.940'))
+            .toBe(true);
+        expect(isChronologicalDelta('conway1.451.1357-ci_1.543.1513_delta.csv', '1.543.1513')).toBe(true);
+        // Cross-engine: starts with webifc, so never matched.
+        expect(isChronologicalDelta('webifc0.0.67_conway0.23.940_delta.csv', '0.23.940')).toBe(false);
+        // Wrong release.
+        expect(isChronologicalDelta('conway0.22.921_0.23.940_delta.csv', '1.543.1513')).toBe(false);
+        // Not a delta at all.
+        for (const name of ['performance-detail.csv', 'performance.csv',
+            'README.md', 'index.html', '00-command.log.txt']) {
+            expect(isChronologicalDelta(name, '0.23.940')).toBe(false);
+        }
+    });
+});

package/compiled/src/scripts/perf_csv_quoting.test.d.ts

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

package/compiled/src/scripts/perf_csv_quoting.test.d.ts.map

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

package/compiled/src/scripts/perf_csv_quoting.test.js

@@ -0,0 +1,300 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, expect, test, beforeAll, afterAll } from '@jest/globals';
+import { createRequire } from 'module';
+/**
+ * RFC 4180 quoting in the perf CSVs (`performance-detail.csv` and the delta
+ * CSVs derived from it).
+ *
+ * `preprocessorVersion` and `originatingSystem` are free text lifted straight
+ * out of an IFC/STEP FILE_NAME header. Emitted unquoted, a value like
+ * `Trimble Nova (Build = 16.2.0.15, Compile = Sep 23 2021)` splits the record
+ * into 16 columns against a 15-column header — which is exactly what five
+ * committed rows in test-models / test-models-private did, and why GitHub's
+ * CSV viewer refused to render them.
+ *
+ * Both halves are pinned here: the writer must quote, and the reader
+ * gen_delta_csv.cjs uses must honour the quotes, or the join silently reads
+ * the wrong columns.
+ */
+const require_ = createRequire(import.meta.url);
+// Resolved from the repo root rather than relative to this file: the test runs
+// from compiled/src/scripts, where a relative hop would land in
+// compiled/scripts, which does not exist (scripts/ is not part of the tsc
+// build). Jest's rootDir is the repo root.
+const { csvField, csvRow, parseCsv } = require_(path.resolve(process.cwd(), 'scripts/csv_rfc4180.cjs'));
+const { generateDeltaCSV } = require_(path.resolve(process.cwd(), 'scripts/gen_delta_csv.cjs'));
+/**
+ * The shape that broke, plus a double quote — the IFC header field can carry
+ * one and nothing in the pipeline was escaping it either.
+ */
+const NASTY_PREPROCESSOR = 'Trimble Nova (Build = 16.2.0.15, Compile = "Sep 23 2021")';
+/** Columns in the delta CSV, per the committed `*_delta.csv` convention. */
+const DELTA_COLUMN_COUNT = 18;
+const DETAIL_HEADER = [
+    'timestamp', 'loadStatus', 'uname', 'engine', 'filename', 'schemaVersion',
+    'parseTimeMs', 'geometryTimeMs', 'totalTimeMs', 'geometryMemoryMb',
+    'rssMb', 'heapUsedMb', 'heapTotalMb', 'preprocessorVersion',
+    'originatingSystem',
+];
+/**
+ * Build a performance-detail.csv row the way scripts/benchmark.cjs does —
+ * through csvRow, every field, in column order.
+ *
+ * @param filename Model filename (the delta's join key).
+ * @param totalTimeMs Total load time for the row.
+ * @return The encoded record, without a trailing newline.
+ */
+function detailRow(filename, totalTimeMs) {
+    return csvRow([
+        '20260811153721', 'OK', 'x64', 'conway1.451.1357', filename, 'IFC2X3',
+        '71', '245', totalTimeMs, '0.776', '300.859', '137.000', '157.582',
+        NASTY_PREPROCESSOR, 'N/A',
+    ]);
+}
+let workDir;
+beforeAll(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'perf-csv-quoting-'));
+});
+afterAll(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+describe('csvField', () => {
+    test('leaves a field with no special characters alone', () => {
+        expect(csvField('conway1.451.1357')).toBe('conway1.451.1357');
+        // A number field is stringified, not quoted.
+        expect(csvField(Number('48303'))).toBe('48303');
+    });
+    test('quotes a comma and doubles an embedded quote', () => {
+        // Written out literally rather than compared against a round trip: this
+        // pins the on-disk encoding, so a reader that is not parseCsv (GitHub's
+        // CSV viewer, python csv, a spreadsheet) reads it back the same way.
+        expect(csvField(NASTY_PREPROCESSOR)).toBe('"Trimble Nova (Build = 16.2.0.15, Compile = ""Sep 23 2021"")"');
+    });
+    test('quotes embedded newlines', () => {
+        expect(csvField('line one\nline two')).toBe('"line one\nline two"');
+        expect(csvField('line one\r\nline two')).toBe('"line one\r\nline two"');
+    });
+    test('renders null and undefined as the empty field', () => {
+        expect(csvField(null)).toBe('');
+        expect(csvField(undefined)).toBe('');
+    });
+});
+describe('performance-detail.csv rows', () => {
+    test('a preprocessorVersion with a comma and a quote round-trips', () => {
+        const text = `${csvRow(DETAIL_HEADER)}\n${detailRow('mep.ifc', '326')}\n`;
+        const records = parseCsv(text);
+        expect(records).toHaveLength(2);
+        // The whole point: 15 columns, not 16.
+        expect(records[0]).toHaveLength(DETAIL_HEADER.length);
+        expect(records[1]).toHaveLength(DETAIL_HEADER.length);
+        const preprocessorIndex = DETAIL_HEADER.indexOf('preprocessorVersion');
+        expect(records[1][preprocessorIndex]).toBe(NASTY_PREPROCESSOR);
+        expect(records[1][DETAIL_HEADER.indexOf('originatingSystem')]).toBe('N/A');
+        // A field after the comma still lands in its own column, which is what a
+        // torn row loses.
+        expect(records[1][DETAIL_HEADER.indexOf('totalTimeMs')]).toBe('326');
+    });
+    test('a filename containing a comma stays one column', () => {
+        // The FAIL path writes the raw model name, and models in the corpus are
+        // named this way ("Wiesenplatz 7, 4057 Basel.ifc").
+        const name = 'Wiesenplatz 7, 4057 Basel.ifc';
+        const records = parseCsv(`${csvRow(DETAIL_HEADER)}\n${detailRow(name, '12')}\n`);
+        expect(records[1]).toHaveLength(DETAIL_HEADER.length);
+        expect(records[1][DETAIL_HEADER.indexOf('filename')]).toBe(name);
+    });
+});
+describe('gen_delta_csv.cjs', () => {
+    /**
+     * Write a two-row performance-detail.csv into the work dir.
+     *
+     * @param name File basename to write.
+     * @param rows Encoded records.
+     * @return The absolute path written.
+     */
+    function writeDetail(name, rows) {
+        const filePath = path.join(workDir, name);
+        fs.writeFileSync(filePath, `${csvRow(DETAIL_HEADER)}\n${rows.join('\n')}\n`);
+        return filePath;
+    }
+    test('joins on filename across quoted fields and emits 18 columns', () => {
+        const older = writeDetail('older.csv', [
+            detailRow('mep.ifc', '400'),
+            detailRow('only-in-older.ifc', '100'),
+        ]);
+        const newer = writeDetail('newer.csv', [
+            detailRow('mep.ifc', '300'),
+            detailRow('only-in-newer.ifc', '200'),
+        ]);
+        const out = path.join(workDir, 'delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        expect(header).toHaveLength(DELTA_COLUMN_COUNT);
+        for (const record of records) {
+            expect(record).toHaveLength(DELTA_COLUMN_COUNT);
+        }
+        const byFile = new Map(records.slice(1).map((r) => [r[header.indexOf('filename')], r]));
+        // The join found the shared model despite the comma-bearing field sitting
+        // between the columns it reads.
+        expect(byFile.get('mep.ifc')[header.indexOf('totalTimeMsDelta')]).toBe('-100');
+        expect(byFile.get('mep.ifc')[header.indexOf('totalTimeMsPercentageChange')])
+            .toBe('-25.00%');
+        // A model present in only one run is reported, not dropped — the corpus
+        // changes between releases and those rows are the interesting ones.
+        expect(byFile.get('only-in-older.ifc')[header.indexOf('loadStatus2')])
+            .toBe('N/A');
+        expect(byFile.get('only-in-newer.ifc')[header.indexOf('loadStatus1')])
+            .toBe('N/A');
+    });
+    test('joins on a filename that itself contains a comma', () => {
+        // filename sits at column 5, ahead of every measurement column the delta
+        // reads, so this is the case where a reader that ignores quoting does not
+        // merely drop a trailing cell — it shifts loadStatus, totalTimeMs and the
+        // rest one place right and joins on a fragment. The FAIL path writes the
+        // raw model name, and the corpus contains names like this one.
+        const name = 'Wiesenplatz 7, 4057 Basel.ifc';
+        const older = writeDetail('comma-older.csv', [detailRow(name, '400')]);
+        const newer = writeDetail('comma-newer.csv', [detailRow(name, '300')]);
+        const out = path.join(workDir, 'comma-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        expect(records).toHaveLength(2);
+        expect(records[1]).toHaveLength(DELTA_COLUMN_COUNT);
+        expect(records[1][header.indexOf('filename')]).toBe(name);
+        expect(records[1][header.indexOf('totalTimeMsDelta')]).toBe('-100');
+        expect(records[1][header.indexOf('loadStatus1')]).toBe('OK');
+    });
+    test('reports an absent measurement as N/A, not as a delta against zero', () => {
+        // The bug this pins: parseValue used to coerce 'N/A' to 0, so a matched row
+        // whose newer side has no geometryMemoryMb came out as
+        // geometryMemoryMbDelta = -(the whole baseline allocation) — a fabricated
+        // 100% memory win. It reported -185.836 for SKYLARK250, which is exactly
+        // the model someone reads this delta for.
+        const withMemory = csvRow([
+            '20260811154725', 'OK', 'x64', 'conway1.451.1357', 'skylark.ifc', 'IFC4',
+            '5729', '42572', '48303', '185.836', '5495.645', '3865.072', '3952.602',
+            NASTY_PREPROCESSOR, 'N/A',
+        ]);
+        // The conway-native perf writer does not measure geometryMemoryMb.
+        const withoutMemory = csvRow([
+            '20260821154725', 'OK', 'x64', 'conway1.543.1513-ci', 'skylark.ifc',
+            'N/A', '8035', '72371', '80406', 'N/A', '5379.12', '3793.69', '3877.96',
+            'N/A', 'N/A',
+        ]);
+        const older = writeDetail('mem-older.csv', [withMemory]);
+        const newer = writeDetail('mem-newer.csv', [withoutMemory]);
+        const out = path.join(workDir, 'mem-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        const row = records[1];
+        expect(row[header.indexOf('geometryMemoryMbDelta')]).toBe('N/A');
+        // The columns that ARE measured on both sides still compute.
+        expect(row[header.indexOf('totalTimeMsDelta')]).toBe('32103');
+        expect(row[header.indexOf('rssMbDelta')]).not.toBe('N/A');
+    });
+    test('reports a FAIL row as N/A rather than a 100% improvement', () => {
+        // Same coercion, and this is where it did the most damage: a model that
+        // regressed OK -> FAIL used to read as totalTimeMsDelta = -(its old total)
+        // with a -100.00% change, i.e. the biggest "improvement" in the file.
+        const okRow = detailRow('flipper.ifc', '48303');
+        const failRow = csvRow([
+            '20260821153721', 'FAIL', 'x64', 'conway1.543.1513', 'flipper.ifc',
+            'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',
+        ]);
+        const older = writeDetail('fail-older.csv', [okRow]);
+        const newer = writeDetail('fail-newer.csv', [failRow]);
+        const out = path.join(workDir, 'fail-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        const row = records[1];
+        expect(row[header.indexOf('loadStatus1')]).toBe('OK');
+        expect(row[header.indexOf('loadStatus2')]).toBe('FAIL');
+        expect(row[header.indexOf('totalTimeMsDelta')]).toBe('N/A');
+        expect(row[header.indexOf('totalTimeMsPercentageChange')]).toBe('N/A');
+        expect(row[header.indexOf('geometryTimeMsDelta')]).toBe('N/A');
+    });
+    test('a real zero is still a number, not treated as absent', () => {
+        // web-ifc rows carry parseTimeMs/geometryTimeMs of literally 0 because that
+        // engine does not split the stages, so "0" and "no measurement" must stay
+        // distinguishable.
+        const zeroed = (engine, total) => csvRow([
+            '20260811154725', 'OK', 'x64', engine, 'z.ifc', 'IFC4',
+            '0', '0', total, '1.5', '100', '50', '60', 'N/A', 'N/A',
+        ]);
+        const older = writeDetail('zero-older.csv', [zeroed('webifc0.0.67', '100')]);
+        const newer = writeDetail('zero-newer.csv', [zeroed('webifc0.0.67', '150')]);
+        const out = path.join(workDir, 'zero-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        const row = records[1];
+        expect(row[header.indexOf('parseTimeMsDelta')]).toBe('0');
+        expect(row[header.indexOf('totalTimeMsDelta')]).toBe('50');
+        expect(row[header.indexOf('totalTimeMsPercentageChange')]).toBe('50.00%');
+    });
+    test('joins a raw filename on one side to its encoded form on the other', () => {
+        // benchmark.cjs URL-encoded the filename on its OK path but wrote the raw
+        // name on its render-failure path, so a committed baseline can hold both
+        // spellings of one model. The writer is fixed, but those files are history:
+        // without the canonical fallback the delta emits two one-sided rows and
+        // loses the OK -> FAIL transition, which is the row that matters most.
+        const rawFail = csvRow([
+            '20260811154725', 'FAIL', 'x64', 'conway1.451.1357',
+            'S_Office_Integrated Design Archi.ifc', 'N/A', 'N/A', 'N/A', 'N/A',
+            'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',
+        ]);
+        const encodedOk = detailRow('S_Office_Integrated%20Design%20Archi.ifc', '4647');
+        const older = writeDetail('enc-older.csv', [rawFail]);
+        const newer = writeDetail('enc-newer.csv', [encodedOk]);
+        const out = path.join(workDir, 'enc-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        // One row, not two one-sided ones.
+        expect(records).toHaveLength(2);
+        expect(records[1][header.indexOf('loadStatus1')]).toBe('FAIL');
+        expect(records[1][header.indexOf('loadStatus2')]).toBe('OK');
+    });
+    test('does not collapse two models whose names differ only by encoding', () => {
+        // The fallback must not become a normalizing join: a corpus that really
+        // contained both spellings as distinct files has to keep them distinct.
+        const older = writeDetail('amb-older.csv', [
+            detailRow('a b.ifc', '100'),
+            detailRow('a%20b.ifc', '200'),
+        ]);
+        const newer = writeDetail('amb-newer.csv', [detailRow('a b.ifc', '150')]);
+        const out = path.join(workDir, 'amb-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        const byFile = new Map(records.slice(1).map((r) => [r[header.indexOf('filename')], r]));
+        expect(byFile.size).toBe(2);
+        // The exact match wins.
+        expect(byFile.get('a b.ifc')[header.indexOf('totalTimeMsDelta')]).toBe('50');
+        // The other stays one-sided rather than stealing the same counterpart.
+        expect(byFile.get('a%20b.ifc')[header.indexOf('loadStatus2')]).toBe('N/A');
+    });
+    test('reports a model whose loadStatus changed between runs', () => {
+        const okRow = detailRow('flipper.ifc', '500');
+        const failRow = csvRow([
+            '20260821153721', 'FAIL', 'x64', 'conway1.543.1513', 'flipper.ifc',
+            'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',
+            NASTY_PREPROCESSOR, 'N/A',
+        ]);
+        const older = writeDetail('status-older.csv', [okRow]);
+        const newer = writeDetail('status-newer.csv', [failRow]);
+        const out = path.join(workDir, 'status-delta.csv');
+        generateDeltaCSV(older, newer, out);
+        const records = parseCsv(fs.readFileSync(out, 'utf8'));
+        const header = records[0];
+        const row = records[1];
+        expect(records).toHaveLength(2);
+        expect(row[header.indexOf('loadStatus1')]).toBe('OK');
+        expect(row[header.indexOf('loadStatus2')]).toBe('FAIL');
+    });
+});

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.543.1513';
+const versionString = 'Conway v1.548.1514';
 export { versionString };