@bldrs-ai/conway 1.476.1409 → 1.484.1410

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.476.1409";
+var versionString = "Conway v1.484.1410";
 
 // 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.476.1409";
+var versionString = "Conway v1.484.1410";
 
 // 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.476.1409";
+var versionString = "Conway v1.484.1410";
 
 // 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.476.1409";
+var versionString = "Conway v1.484.1410";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/ifc/ifc_regression_batch_main.js

@@ -88,6 +88,39 @@ function csvSafeString(from) {
     }
     return from;
 }
+/**
+ * Read back the first field of a line written with csvSafeString.
+ *
+ * Naive `line.split(',')[0]` is wrong for exactly the inputs csvSafeString
+ * exists for: a model filename containing a comma comes back quoted, and
+ * splitting on ',' truncates it mid-name. The zero-geometry collision check
+ * keys on this field, so a truncated name silently changes which stems it
+ * thinks collide.
+ *
+ * @param line A CSV line whose first field was written by csvSafeString.
+ * @return {string} The unescaped first field.
+ */
+function csvFirstField(line) {
+    const trimmed = line.replace(/[\r\n]+$/, '');
+    if (!trimmed.startsWith('"')) {
+        return trimmed.split(',')[0];
+    }
+    let result = '';
+    for (let cursor = 1; cursor < trimmed.length; ++cursor) {
+        if (trimmed[cursor] !== '"') {
+            result += trimmed[cursor];
+            continue;
+        }
+        // A doubled quote is a literal one; a lone quote closes the field.
+        if (trimmed[cursor + 1] === '"') {
+            result += '"';
+            ++cursor;
+            continue;
+        }
+        break;
+    }
+    return result;
+}
 /**
  * Encapsulates a string in a CSV safe way, taking
  * file paths (assumed by directory characters / and \,
@@ -206,6 +239,15 @@ async function runForFile(filePath, outputPath, maxTimeout, perfPath) {
         './compiled/src/ifc/ifc_regression_main.js';
     const safeExecCommand = `node --experimental-specifier-resolution=node ${childScript} -d${perfFlag} "${filePath}" "${outputPath}"`;
     console.log(`Current File: ${filePath}`);
+    // Remove any stale digest before the child runs. Without this, a child that
+    // dies without writing one leaves the committed baseline CSV in place, the
+    // batch hashes THAT, and the model reports an unchanged hash with no failure
+    // and no zero-geometry row - green, while extraction is completely broken.
+    // That is precisely the case this gate exists to catch.
+    const staleDigest = `${outputPath}.csv`;
+    if (fs.existsSync(staleDigest)) {
+        await fsPromises.rm(staleDigest, { force: true });
+    }
     // Use safeExecWithCancellation, will kill the process if it takes longer than MAX_TIMEOUT_MS.
     const process = await safeExecWithCancellation(safeExecCommand, MAX_TIMEOUT_MS);
     totalTime += Date.now() - startTime;
@@ -228,54 +270,41 @@ async function runForFile(filePath, outputPath, maxTimeout, perfPath) {
     }
     const outputFile = path.basename(outputPath);
     let fileHash;
+    // Absent digest counts as zero geometry: the stale file was removed before
+    // the child ran, so nothing here can be left over from the committed
+    // baseline. A child that dies without writing one is exactly the case this
+    // gate exists to catch, and hashing the old file would report it as green.
+    let producedNoGeometry = true;
     const outputCSV = `${outputPath}.csv`;
     if (fs.existsSync(outputCSV)) {
+        const digest = await fsPromises.readFile(outputCSV);
         fileHash = crypto
             .createHash('sha1')
-            .update(await fsPromises.readFile(outputCSV))
+            .update(digest)
             .digest('hex');
+        // A digest with nothing after its header means the model loaded and
+        // produced no geometry at all. The child still exits 0, so this is
+        // invisible to every other signal the harness has — see #477 / #478.
+        //
+        // Known limitation: a digest row is any hashed entity, and that includes
+        // non-renderable ones (IFCSURFACESTYLE, IFCPOLYLINE, IFCCENTERLINEPROFILEDEF
+        // …), so "has rows" is weaker than "has renderable geometry". A model that
+        // emits only styles and profiles reads as fine here. That is a deliberate
+        // floor, not an oversight: this catches the total-blank case with zero
+        // false positives, which is what an unconditional CI gate needs. Tightening
+        // it to a mesh/vertex count means teaching the digest which types are
+        // renderable and re-blessing every baseline; tracked on #478.
+        producedNoGeometry =
+            digest.toString('utf8').split('\n').filter((line) => line.trim().length > 0).length <= 1;
     }
     return {
         type: 'Run',
         errorLines: errorLines.length > 0 ? errorLines : undefined,
         outputFile,
         hash: fileHash,
+        producedNoGeometry,
     };
 }
-/**
- * Run a file's digest, retrying ONCE if the first attempt times out.
- *
- * A per-model timeout is not a deterministic parse/geometry failure — it
- * surfaces as a failed.csv row with an empty code AND empty signal (the
- * TimeoutError path sets neither) and, historically, has come from transient
- * core oversubscription on the CI runner rather than the model itself.
- * ISSUE_159_kleine_Wohnung_R22.ifc (a geometry-dense ~18.5k-item model) has
- * reddened the rc-regression gate this way twice: first co-scheduled at
- * --concurrency 2, then again running ALONE at --concurrency 1, so serializing
- * the batch was not enough to make it reliable.
- *
- * Digest regeneration is idempotent, so a second attempt is safe: a transient
- * timeout clears on the retry, while a genuine hang times out both times and
- * still lands in failed.csv — the gate keeps its protective value against a
- * model that truly never loads. Only timeouts are retried; a real non-zero
- * exit or signal is returned immediately (those ARE deterministic).
- *
- * @param filePath   Model file to digest.
- * @param outputPath Digest output path (without extension).
- * @param maxTimeout Per-attempt timeout in ms.
- * @param perfPath   Optional path the child writes its one-row perf CSV to.
- * @return The first attempt's result, or the retry's result on a timeout.
- */
-async function runForFileWithTimeoutRetry(filePath, outputPath, maxTimeout, perfPath) {
-    const timedOut = (r) => r.type === 'Failed' && r.message === 'Execution timed out';
-    const first = await runForFile(filePath, outputPath, maxTimeout, perfPath);
-    if (!timedOut(first)) {
-        return first;
-    }
-    console.log(`"${path.basename(filePath)}" timed out; retrying once ` +
-        `(a transient timeout clears, a true hang times out again).`);
-    return runForFile(filePath, outputPath, maxTimeout, perfPath);
-}
 // Model files the regression harness understands: IFC plus STEP AP214.
 const SUPPORTED_MODEL_EXTENSIONS = ['.ifc', '.stp', '.step'];
 /**
@@ -355,12 +384,13 @@ function getSystemMemoryUsagePercent() {
  * @param errorLines
  * @param fileLines
  * @param failedLines
+ * @param zeroGeometryLines
  * @param memUtilization
  * @param maxTimeout
  * @param concurrency Max children processed at once (>= 1).
  * @param perfDir If set, the child writes its perf CSV here as <basename>.perf.csv.
  */
-async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout, concurrency, perfDir) {
+async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, memUtilization, maxTimeout, concurrency, perfDir) {
     const concurrencyLimit = Math.max(1, concurrency);
     console.log(`Concurrency: ${concurrencyLimit} children - Max Timeout: ${maxTimeout} ms`);
     const limit = pLimit(concurrencyLimit);
@@ -378,7 +408,7 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
         const perfChildPath = perfDir ?
             path.join(perfDir, `${path.parse(ifcPath).name}.perf.csv`) :
             undefined;
-        const fileResults = await runForFileWithTimeoutRetry(ifcPath, path.join(outputPath, path.parse(ifcPath).name), maxTimeout, perfChildPath);
+        const fileResults = await runForFile(ifcPath, path.join(outputPath, path.parse(ifcPath).name), maxTimeout, perfChildPath);
         activeTasks--;
         console.log(`Completed task for "${path.basename(ifcPath)}". Active tasks: ${activeTasks}`);
         return { ifcPath, fileResults };
@@ -394,6 +424,9 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
             fileLines.push(`${csvSafeString(path.basename(ifcPath))},` +
                 `${csvSafeString(fileResults.hash ?? '')},` +
                 `${fileResults.errorLines?.length ?? 0}\n`);
+            if (fileResults.producedNoGeometry) {
+                zeroGeometryLines.push(`${csvSafeString(path.basename(ifcPath))}\n`);
+            }
         }
         else {
             // it's 'Failed'
@@ -412,10 +445,11 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
  * @param errorLines
  * @param fileLines
  * @param failedLines
+ * @param zeroGeometryLines
  * @param maxTimeout
  * @param perfDir If set, the child writes its perf CSV here as <basename>.perf.csv.
  */
-async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfDir) {
+async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfDir) {
     const items = await fsPromises.readdir(parentPath, { withFileTypes: true });
     items.sort((a, b) => (a.name > b.name ? 1 : -1));
     for (const item of items) {
@@ -424,18 +458,21 @@ async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, f
             continue;
         }
         if (item.isDirectory()) {
-            await recursiveWalk(resolved, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfDir);
+            await recursiveWalk(resolved, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfDir);
         }
         else if (isSupportedModelFile(resolved)) {
             const perfChildPath = perfDir ?
                 path.join(perfDir, `${path.parse(resolved).name}.perf.csv`) :
                 undefined;
-            const fileResults = await runForFileWithTimeoutRetry(resolved, path.join(outputPath, path.parse(resolved).name), maxTimeout, perfChildPath);
+            const fileResults = await runForFile(resolved, path.join(outputPath, path.parse(resolved).name), maxTimeout, perfChildPath);
             if (fileResults.type === 'Run') {
                 if (fileResults.errorLines !== void 0) {
                     errorLines.push(...fileResults.errorLines);
                 }
                 fileLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.hash ?? '')},${fileResults.errorLines?.length ?? 0}\n`);
+                if (fileResults.producedNoGeometry) {
+                    zeroGeometryLines.push(`${csvSafeString(path.basename(resolved))}\n`);
+                }
             }
             else {
                 failedLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.code?.toString() ?? '')},${csvSafeString(fileResults.signal ?? '')}\n`);
@@ -557,25 +594,60 @@ const args = yargs(process.argv.slice(SKIP_PARAMS))
     const mainPath = path.join(outputPath, 'main.csv');
     const errorPath = path.join(outputPath, 'errors.csv');
     const failedPath = path.join(outputPath, 'failed.csv');
+    const zeroGeometryPath = path.join(outputPath, 'zero_geometry.csv');
     const errorLines = [];
     const fileLines = [];
     const failedLines = [];
+    const zeroGeometryLines = [];
     const excludeRegex = excludeFilter.length > 0 ? new RegExp(excludeFilter) : undefined;
     if (doParallel) {
         console.log('Processing in parallel mode...');
         // 1) Collect all IFC files first
         const allIFCFiles = await collectIFCFiles(ifcFolder, excludeRegex);
         // 2) Process them in parallel
-        await processIFCFilesInParallel(allIFCFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout, concurrency, perfTmpDir);
+        await processIFCFilesInParallel(allIFCFiles, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, memUtilization, maxTimeout, concurrency, perfTmpDir);
     }
     else {
         console.log('Processing in serial mode...');
-        await recursiveWalk(ifcFolder, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout, perfTmpDir);
+        await recursiveWalk(ifcFolder, excludeRegex, outputPath, errorLines, fileLines, failedLines, zeroGeometryLines, maxTimeout, perfTmpDir);
     }
     // Write out results
     await fsPromises.writeFile(mainPath, `file,hash,errors\n${fileLines.join('')}`);
     await fsPromises.writeFile(errorPath, `${errorCSVHeader}\n${errorLines.join('')}`);
     await fsPromises.writeFile(failedPath, `file,code,signal\n${failedLines.join('')}`);
+    // Models that loaded and produced no geometry. Written as its own
+    // artifact rather than folded into failed.csv, because the two need
+    // different gates: failed.csv is empty and stays empty, while a
+    // handful of zero-geometry models are known and tracked (#477), so
+    // CI compares this against an explicit allowlist instead.
+    // Models whose digest stem collides cannot be judged: two models
+    // sharing a basename write the SAME digest file, so in --parallel one
+    // can be read between another's truncate and its first row. That
+    // collision is a pre-existing harness bug (it also means the blessed
+    // digest is whichever model ran last) - `ifc/index.ifc` and
+    // `ifc/bldrs/index.ifc` are a live example, both in the smoke subset.
+    // Suppress rather than guess, so it cannot red an unrelated PR, and
+    // say so loudly.
+    const stemCounts = new Map();
+    for (const line of fileLines) {
+        const stem = path.parse(csvFirstField(line)).name;
+        stemCounts.set(stem, (stemCounts.get(stem) ?? 0) + 1);
+    }
+    const collidingStems = new Set([...stemCounts].filter(([, count]) => count > 1).map(([stem]) => stem));
+    if (collidingStems.size > 0) {
+        console.warn(`WARNING: ${collidingStems.size} digest stem(s) are written by more ` +
+            `than one model, so their digests overwrite each other and their ` +
+            `zero-geometry status cannot be determined: ${[...collidingStems].join(', ')}`);
+    }
+    const reportableZeroGeometry = zeroGeometryLines.filter((line) => !collidingStems.has(path.parse(csvFirstField(line)).name));
+    await fsPromises.writeFile(zeroGeometryPath, `file\n${reportableZeroGeometry.join('')}`);
+    if (reportableZeroGeometry.length > 0) {
+        console.log(`\n${reportableZeroGeometry.length} model(s) loaded but produced NO geometry:`);
+        for (const line of reportableZeroGeometry) {
+            console.log(`  ${line.trim()}`);
+        }
+        console.log('');
+    }
     // Aggregate per-child perf rows (if requested) before runDiff so the
     // run completes deterministically even when the git diff step is
     // skipped or fails.

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