elanous 0.2.17 → 0.2.19

package/scripts/pch-regress.ts

@@ -0,0 +1,88 @@
+// V1-PCH — rerun existing PWA chat gap tests by document slot, once per release.
+//
+//   bun scripts/pch-regress.ts [--only PCH-1,PCH-5] [--json]
+//
+// ⛔ Not under `bun test`: this release runner itself invokes bun test in apps/pwa, one slot at a time;
+// putting it in the test gate would recursively run the PWA tests instead of testing the runner with a fake executor.
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PCH_REGRESS_MAP } from './lib/pch-regress-map.js';
+
+export type TestExecution = { status: number | null; stdout: string; stderr: string; error?: Error };
+export type TestExecutor = (files: readonly string[], cwd: string) => TestExecution;
+export type PchResult = { id: string; files: readonly string[]; status: 'pass' | 'fail' | '시험 없음'; failure: string };
+
+const PWA_DIR = join(import.meta.dir, '..', 'apps', 'pwa');
+
+export const runBunTests: TestExecutor = (files, cwd) => {
+  const result = spawnSync('bun', ['test', ...files], { cwd, encoding: 'utf8' });
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '', ...(result.error ? { error: result.error } : {}) };
+};
+
+function firstFailure(output: string): string {
+  const lines = output.replace(/\x1b\[[0-9;]*m/g, '').split(/\r?\n/).map((line) => line.trim());
+  return lines.find((line) => /^\(fail\)\s|^[✗✘❌]\s/.test(line))
+    ?? lines.find((line) => /^error:/i.test(line))
+    ?? lines.find((line) => /^# Unhandled error/i.test(line))
+    ?? lines.find(Boolean)
+    ?? 'bun test 종료 오류 (출력 없음)';
+}
+
+export function runPchRegress(
+  args: readonly string[],
+  executor: TestExecutor = runBunTests,
+  map: Readonly<Record<string, readonly string[]>> = PCH_REGRESS_MAP,
+  depsInstalled: () => boolean = () => existsSync(join(PWA_DIR, 'node_modules', 'react')),
+): { results: PchResult[]; exitCode: number; output: string } {
+  let only: Set<string> | null = null;
+  let json = false;
+  for (let index = 0; index < args.length; index++) {
+    if (args[index] === '--json') json = true;
+    else if (args[index] === '--only' && args[index + 1] && !args[index + 1]!.startsWith('--')) {
+      only = new Set(args[++index]!.split(',').map((id) => id.trim()).filter(Boolean));
+    } else return { results: [], exitCode: 2, output: `pch-regress: 알 수 없거나 값이 없는 옵션: ${args[index]}` };
+  }
+  const unknown = [...(only ?? [])].filter((id) => !(id in map));
+  if (unknown.length) return { results: [], exitCode: 2, output: `pch-regress: 없는 칸: ${unknown.join(', ')}` };
+  const entries = Object.entries(map).filter(([id]) => !only || only.has(id));
+  if (!entries.length) return { results: [], exitCode: 2, output: 'pch-regress: 고른 칸이 없다 (--only 확인)' };
+
+  // Without apps/pwa deps every slot fails on `Cannot find package 'react'` — an environment gap, not a regression.
+  if (entries.some(([, files]) => files.length) && !depsInstalled()) {
+    return { results: [], exitCode: 2, output: 'pch-regress: apps/pwa 의존성이 없다 (node_modules/react) — 먼저 `cd apps/pwa && bun install`' };
+  }
+  const results: PchResult[] = [];
+  for (const [id, files] of entries) {
+    if (!files.length) {
+      results.push({ id, files, status: '시험 없음', failure: '' });
+      continue;
+    }
+    try {
+      const run = executor(files, PWA_DIR);
+      const output = `${run.stderr}\n${run.stdout}`;
+      const completed = /\bRan [1-9]\d* tests? across\b/.test(output);
+      const passed = /^[ \t]*[1-9]\d* pass\b/m.test(output);
+      const status = run.status === 0 && completed && passed && !run.error ? 'pass' : 'fail';
+      results.push({ id, files, status, failure: status === 'fail' ? (run.error?.message ?? (run.status === 0 && !passed ? '통과한 시험 없음 (0 pass)' : firstFailure(output))) : '' });
+    } catch (error) {
+      results.push({ id, files, status: 'fail', failure: String(error) });
+    }
+  }
+  const fail = results.filter((row) => row.status === 'fail').length;
+  const output = json
+    ? JSON.stringify({ results, pass: results.filter((row) => row.status === 'pass').length, fail, noTests: results.filter((row) => row.status === '시험 없음').length })
+    : [
+      '| 칸 | 파일 수 | 시험 파일 | 결과 | 실패한 시험 이름 첫 줄 |',
+      '|---|---:|---|---|---|',
+      ...results.map((row) => `| ${row.id} | ${row.files.length} | ${row.files.join(', ') || '—'} | ${row.status} | ${row.failure.replace(/\|/g, '\\|')} |`),
+      `pch-regress: pass ${results.length - fail - results.filter((row) => row.status === '시험 없음').length} · fail ${fail} · 시험 없음 ${results.filter((row) => row.status === '시험 없음').length}`,
+    ].join('\n');
+  return { results, exitCode: fail ? 1 : 0, output };
+}
+
+if (import.meta.main) {
+  const result = runPchRegress(process.argv.slice(2));
+  (result.exitCode === 2 ? console.error : console.log)(result.output);
+  process.exitCode = result.exitCode;
+}

package/scripts/public-export-test-run.ts

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { run as exportRun } from './public-export.js';
+import { privateRedactionsPath, run as exportRun } from './public-export.js';
 
 export interface Comparison {
   exportOnly: string[];
@@ -118,4 +118,39 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
   }
 }
 
-if (import.meta.main) process.exit(run(process.argv.slice(2)));
+// GATE-REMOTE (10-06): `--remote [host]` runs the same commit on that host and prints its result (JSON gains host · remote:true);
+//   `--local` forces this machine. Without either, a busy machine (1-min load > gateRemote.loadThreshold) dispatches on its own.
+if (import.meta.main) void (async () => {
+  const { extractGateRemoteFlags, dispatchHeavyCheck, unreproducibleArgs, relativizeArgs } = await import('../src/self-implement/gate-remote.js');
+  const flags = extractGateRemoteFlags(process.argv.slice(2));
+  if (flags.error) { console.error(flags.error); process.exit(2); }
+  const repo = resolve(import.meta.dir, '..');
+  // The private redaction table changes exported file contents — the remote export must use the same one or the comparison differs.
+  const table = privateRedactionsPath();
+  const payloadFiles = existsSync(table) ? [{ env: 'ELANOUS_EXPORT_REDACTIONS', content: readFileSync(table, 'utf8') }] : [];
+  // File arguments, the --files list and its entries resolve against the repository root (as run() does).
+  const paths = flags.rest.filter((arg) => !arg.startsWith('--'));
+  const listIndex = flags.rest.indexOf('--files');
+  const list = listIndex >= 0 ? flags.rest[listIndex + 1] : undefined;
+  // List entries reach the host verbatim (only positional arguments are rewritten), so an absolute entry is not portable.
+  const absoluteEntries: string[] = [];
+  if (list) {
+    try {
+      const entries = readFileSync(resolve(repo, list), 'utf8').split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+      absoluteEntries.push(...entries.filter((entry) => isAbsolute(entry)));
+      paths.push(...entries);
+    } catch { /* run() reports it */ }
+  }
+  process.exitCode = await dispatchHeavyCheck({
+    payloadFiles,
+    localOnlyReason: (() => {
+      // Each must be a tracked file inside the repository, or the remote checkout would measure something else.
+      const bad = [...new Set([...absoluteEntries, ...unreproducibleArgs(paths, repo)])];
+      return bad.length ? `file argument not reproducible on the host (outside the repository or not tracked at HEAD): ${bad.join(' ')}` : undefined;
+    })(),
+    tool: 'public-export-test-run', repo, flags, json: flags.rest.includes('--json'),
+    installPwa: paths.some((arg) => arg.includes('apps/pwa')),
+    remoteArgv: ['bun', 'scripts/public-export-test-run.ts', '--local', ...relativizeArgs(flags.rest, repo)],
+    runLocal: () => run(flags.rest),
+  });
+})();

package/scripts/release-loop/checklist-gate-node.ts

@@ -1,24 +1,25 @@
 #!/usr/bin/env bun
-import { checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { cutChecklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
 import * as store from '../../src/release-loop/feature-store.js';
 import { getSchedule } from '../../src/release-loop/release-schedule.js';
 import { debug } from '../../src/debug/log.js';
+import { prereleaseKind } from './release-version.js';
 import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
 
+/** RELEASE-REHEARSAL-RC: a prerelease rehearses the pipeline; it must not judge or carry the stable version's cells. */
+export function prereleaseChecklistSkip(context: GraphContext) {
+  const version = context.input.version;
+  if (prereleaseKind(version) === null) return null;
+  debug.log('release-loop.checklist-gate', 'skipped', { version, reason: 'prerelease' });
+  return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `checklist gate skipped — ${version} is a prerelease rehearsal`, skipped: 'prerelease' };
+}
+
 export function runChecklistGate(context: GraphContext = readGraphContext(), now: Date = new Date()) {
   const version = context.input.version;
   const data = listChecklist(version);
   const schedule = getSchedule(version);
   const deadline = schedule?.landBy;
-  const overdue = deadline !== null && deadline !== undefined && now.getTime() > Date.parse(deadline);
-  const autoMoved = overdue ? data.items.filter((item) => item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
-  const gate = checklistGate(version);
-  const p0 = data.items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
-  gate.undecided = gate.undecided.filter((id) => !autoMoved.includes(id) && !p0.includes(id));
-  gate.moved = gate.moved.filter((id) => !p0.includes(id)).concat(autoMoved);
-  gate.knownIssues = gate.knownIssues.filter((item) => !p0.includes(item.id));
-  gate.blocked.push(...p0.filter((id) => !gate.blocked.includes(id)));
-  gate.ok = gate.red.length === 0 && gate.undecided.length === 0 && gate.blocked.length === 0;
+  const { autoMoved, ...gate } = cutChecklistGate(version, deadline, now);
   const [major, minor, patch] = version.split('.').map(Number);
   const next = `${major}.${minor}.${patch! + 1}`;
   const carried: string[] = [];
@@ -65,7 +66,8 @@ export function runChecklistGate(context: GraphContext = readGraphContext(), now
 
 if (import.meta.main) {
   try {
-    const result = runChecklistGate();
+    const context = readGraphContext();
+    const result = prereleaseChecklistSkip(context) ?? runChecklistGate(context);
     emitNodeResult(result);
     process.exitCode = result.outcome === 'ok' ? 0 : 1;
   } catch (error) {

package/scripts/release-loop/cut-branch.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { isReleaseVersion } from './release-version.js';
 
 export interface CutBranchOptions { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; repoRoot?: string; log?: (line: string) => void }
 
@@ -26,7 +27,7 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
   const report = (event: 'created' | 'refused' | 'conflict' | 'appended', reason?: string, commit?: string, extra?: Record<string, string | string[]>) =>
     debug.log('release-loop.cut-branch', event, { version: opts.version, branch, ...(commit ? { commit } : {}), ...(reason ? { reason } : {}), ...extra });
   try {
-    if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
+    if (!isReleaseVersion(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
     if (!opts.pick.length) throw new Error('at least one --pick commit is required');
     for (const sha of [opts.base, ...opts.pick]) if (!/^[0-9a-f]{7,40}$/i.test(sha)) throw new Error(`invalid commit SHA: ${sha}`);
     git(repo, ['fetch', 'origin', 'main']);

package/scripts/release-loop/cutoff.ts

@@ -25,8 +25,10 @@ function requiredGit(args: string[]): string {
 }
 
 function versionParts(value: string): number[] | null {
-  if (!/^\d+\.\d+\.\d+$/.test(value)) return null;
-  return value.split('.').map(Number);
+  // A prerelease (0.2.18-rc.0) is placed by its base version — earlier stable tags are its baseline.
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-(?:rc|alpha|beta)\.\d+)?$/.exec(value);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
 
 function compareVersions(a: number[], b: number[]): number {

package/scripts/release-loop/docs-land-node.ts

@@ -7,6 +7,7 @@ import { recordDocsFollow, type DocsFollowItem } from './release-docs.js';
 import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+import { prereleaseKind } from './release-version.js';
 
 export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effectiveInstanceRoot(), ledgerRoot = releaseLedgerRoot()) {
   const context = readGraphContext();
@@ -119,6 +120,12 @@ export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effecti
 
 if (import.meta.main) {
   let version = '';
-  try { version = readGraphContext().input.version; process.exitCode = finishNode('docs-land', version, runDocsLand()); }
+  try {
+    version = readGraphContext().input.version;
+    // RELEASE-REHEARSAL-RC: a prerelease never lands docs on main or upgrades the operating hosts.
+    process.exitCode = finishNode('docs-land', version, prereleaseKind(version) !== null
+      ? { outcome: 'ok', verdict: 'pass', summary: `docs-land skipped — ${version} is a prerelease`, skipped: 'prerelease' }
+      : runDocsLand());
+  }
   catch (error) { process.exitCode = finishNode('docs-land', version, errorResult(error)); }
 }

package/scripts/release-loop/docs-node.ts

@@ -72,7 +72,7 @@ export function runDocs(
       }
       throw new Error(`unknown argument: ${arg}`);
     }
-    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/.test(version)) {
+    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:rc|alpha|beta)\.(?:0|[1-9]\d*))?$/.test(version)) {
       throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version): x.y.z');
     }
     root = resolve(root);

package/scripts/release-loop/gate-diff.ts

@@ -18,6 +18,24 @@ export function parseFailures(output: string): string[] {
   return [...failures].sort();
 }
 
+/** GATE-INTRO-RECHECK (0.2.19) — the failures that are bun's «timed out» shape: a `(fail) name` line whose next line is
+ *  `^ this test timed out after <n>ms.` An assertion failure prints its error above the `(fail)` line, never this. */
+export function parseTimedOutFailures(output: string): string[] {
+  const timedOut = new Set<string>();
+  let file: string | undefined;
+  let pending: string | undefined;
+  for (const raw of output.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (pending && /^\^ this test timed out after \d+(?:\.\d+)?ms\.?$/.test(line)) timedOut.add(pending);
+    pending = undefined;
+    const header = /^(?:\.\/)?((?:[\w.-]+\/)+[\w.-]+\.test\.tsx?):(?:\s|$)/.exec(line);
+    if (header) { file = header[1]; continue; }
+    const failed = /\(fail\)\s+(.+?)(?:\s+\[[\d.]+(?:ms|s)\])?$/.exec(line);
+    if (failed && file) pending = `${file} > ${failed[1]!.trim()}`;
+  }
+  return [...timedOut].sort();
+}
+
 const xmlText = (value: string): string => value
   .replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, '<').replace(/&gt;/g, '>')
   .replace(/&#(\d+);/g, (_, code: string) => String.fromCodePoint(Number(code))).replace(/&amp;/g, '&');