@bldrs-ai/conway 1.449.1351 → 1.451.1357

package/README.md

@@ -185,14 +185,25 @@ git merge -X rename-threshold=25 --no-commit
 
 # CI and Testing
 
+CI is **tiered** so full-corpus regression + performance cost is paid once per
+release candidate, not on every push. Full architecture, cost rationale, and
+the rc/re-bless/LFS runbook: [design/new/ci-regression-cost.md](design/new/ci-regression-cost.md).
+
 Every PR is gated on two checks defined in `.github/workflows/build.yml`:
 
 | Job | What it does |
 |---|---|
 | `build` | `yarn install`, WASM + TS compile (WASM cached on the `conway-geom` submodule SHA), `yarn test`, `yarn lint`, and a Tier-A geometry-digest check of the in-repo `data/` models against committed goldens. |
-| `run-ifc-regression` | `needs: build`. Reuses the same WASM cache. Runs the regression batch against the public `test-models` ref (`TEST_MODELS_REF`, default `main`), pinned per-run to the resolved commit SHA; posts a per-PR comment with the resolved SHA + `failed.csv` / `errors.csv` / perf summaries, and uploads the candidate npm tarball + `perf.csv` as workflow artifacts. |
+| `run-ifc-regression` | `needs: build`. Reuses the same WASM cache. Runs the regression batch over the **smoke subset** (`regression/smoke_models.txt`) of the public `test-models` ref (`TEST_MODELS_REF`, default `main`), pinned per-run to the resolved commit SHA. Fails on any `failed.csv` row; digest *changes* are informational (reviewed via the visual-diff comment, blessed at the rc). Posts a per-PR comment with the resolved SHA + smoke-scoped `failed.csv` / `errors.csv` / perf summaries, and uploads the candidate npm tarball + `perf.csv` as workflow artifacts. |
+
+A `concurrency` group cancels superseded PR runs (main runs are never
+cancelled, so releases always complete). A merge to `main` re-runs those two
+jobs and then chains into `auto-publish` (see [Releases](#releases) below).
 
-A merge to `main` re-runs those two jobs and then chains into `auto-publish` (see [Releases](#releases) below).
+**The full public+private corpus runs once per release candidate** — push an
+`rc-*` tag and `rc-regression.yml` regenerates every baseline (opening a
+reviewable baseline PR per test-models repo) while the `perf-three-*` jobs run
+the full benchmark. See the runbook in the CI-cost doc linked above.
 
 ## Regression batch
 
@@ -209,8 +220,11 @@ The `build` job also runs a fast, hermetic geometry gate over every `data/*.ifc`
 **Tier 1 — Conway-only perf in CI (live).** Every regression run emits a `perf.csv` of `parseTimeMs / geometryTimeMs / totalTimeMs / rssMb / heapUsedMb / heapTotalMb` per model. The top-10 slowest are posted in the PR comment; the full CSV is uploaded as a workflow artifact. This piggybacks on the existing regression batch so cost is ~0 extra runner minutes.
 
 **Tier 2 — full headless-three perf in CI (live).** Two jobs,
-`perf-three-public` and `perf-three-private`, run on `push: main`
-(`needs: run-ifc-regression`). Each downloads the candidate Conway tarball
+`perf-three-public` and `perf-three-private`, run on `rc-*` tags and
+`workflow_dispatch` (`needs: run-ifc-regression`) — once per release
+candidate, not per merge, so per-model timings stay low-variance on the
+isolated runner (see [ci-regression-cost.md](design/new/ci-regression-cost.md)
+for why frequency, not runner size, is the cost lever). Each downloads the candidate Conway tarball
 that the regression job packed, clones [headless-three](https://github.com/bldrs-ai/headless-three)
 at a pinned `H3_SHA`, and forces the whole H3 → adapter → conway chain onto
 the candidate via a yarn `resolutions` override (no `yarn link`), then runs
@@ -305,23 +319,23 @@ npm dist-tag add @bldrs-ai/conway@<VERSION> stable
 
 # Roadmap
 
-The CI / release pipeline is continuous and complete: `build` gates
-`run-ifc-regression`, which gates the headless-three perf jobs, and every
-green merge to `main` auto-publishes (see [Releases](#releases)). The
+The CI / release pipeline is continuous and **tiered**: `build` (fixtures) and
+`run-ifc-regression` (smoke subset) gate every PR; the full public+private
+corpus and the headless-three perf jobs run once per `rc-*` release candidate;
+every green merge to `main` auto-publishes (see [Releases](#releases)). The
+architecture, cost rationale, and rc/re-bless/LFS runbook are in
+[design/new/ci-regression-cost.md](design/new/ci-regression-cost.md). Regression
+renders (the visual-diff comment) and per-model perf-in-CI shipped; the
 umbrella waterfall (#316) and performance-in-CI (#314) issues are closed.
-The optional follow-ups below remain.
-
-### Headless-three perf on PRs
-
-The `perf-three-public` / `perf-three-private` jobs run on `push: main`
-only — to keep PR wall-time down and to keep the private-models token off
-PR events (forks can't be trusted with it). Running them per-PR, behind a
-gate that withholds the private job from fork PRs, would catch H3
-render-time regressions before merge instead of just after.
-
-### Golden `errors.csv` diffing + regression renders (#288)
 
-Fail a PR when its `errors.csv` diverges from a checked-in golden — "New
-errors detected. Copy errors.csv to golden/errors.csv to accept changes"
-— and attach per-model renders to the regression comment so geometry
-regressions are visible without downloading artifacts.
+### Open follow-ups
+
+- **Errors as a hard gate.** `errors.csv` is regenerated and reviewed (and,
+  at the rc, blessed into the baseline), but a PR is not *failed* on unexpected
+  new errors — only on parse/extract failures (`failed.csv`). A golden-errors
+  gate could fail smoke-scoped error churn that isn't an intended change.
+- **Smoke-list curation.** The smoke subset (`regression/smoke_models.txt`)
+  is a hand-picked spread; as the engine's failure surface shifts, revisit
+  which models best catch regressions cheaply.
+- **Perf-threshold gating.** The `perf-three-*` jobs post deltas but don't
+  fail an rc on a regression; a threshold could turn perf into a release gate.

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

package/compiled/src/ifc/ifc_regression_batch_main.js

@@ -242,6 +242,40 @@ async function runForFile(filePath, outputPath, maxTimeout, perfPath) {
         hash: fileHash,
     };
 }
+/**
+ * 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'];
 /**
@@ -344,7 +378,7 @@ async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileL
         const perfChildPath = perfDir ?
             path.join(perfDir, `${path.parse(ifcPath).name}.perf.csv`) :
             undefined;
-        const fileResults = await runForFile(ifcPath, path.join(outputPath, path.parse(ifcPath).name), maxTimeout, perfChildPath);
+        const fileResults = await runForFileWithTimeoutRetry(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 };
@@ -396,7 +430,7 @@ async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, f
             const perfChildPath = perfDir ?
                 path.join(perfDir, `${path.parse(resolved).name}.perf.csv`) :
                 undefined;
-            const fileResults = await runForFile(resolved, path.join(outputPath, path.parse(resolved).name), maxTimeout, perfChildPath);
+            const fileResults = await runForFileWithTimeoutRetry(resolved, path.join(outputPath, path.parse(resolved).name), maxTimeout, perfChildPath);
             if (fileResults.type === 'Run') {
                 if (fileResults.errorLines !== void 0) {
                     errorLines.push(...fileResults.errorLines);

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