@volter/world 3.0.123 → 3.0.125

package/dist/src/cli.js

@@ -138,15 +138,20 @@ async function passthrough(cmd, cwd = process.cwd()) {
         process.on(signal, forward(signal));
     return await new Promise((resolve, reject) => { child.once('error', reject); child.once('exit', (code, signal) => resolve(code ?? (signal ? 128 : 1))); });
 }
-/** All of stdin, as text: a synchronous read of fd 0 to EOF — the same on Bun and Node, and it
- *  holds the process (an async iteration of `process.stdin` here let Bun exit 0 mid-read, the
- *  credential unsealed and nothing said — found by the deploy-from-a-shared-world page). */
-function stdinText() { try {
-    return readFileSync(0, 'utf8');
+/** Read through EOF, including a delayed pipe producer. Bun's stdin iteration can leave the
+ *  event loop unreferenced; the timer holds it until EOF or error and is released in either case. */
+async function stdinText() {
+    const keepAlive = setInterval(() => { }, 1000);
+    try {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        return Buffer.concat(chunks).toString('utf8');
+    }
+    finally {
+        clearInterval(keepAlive);
+    }
 }
-catch {
-    return '';
-} }
 async function worldCommand(verb, args) {
     const worldDir = value(args, '--world');
     const pos = positionals(args, VALUE_FLAGS);
@@ -630,7 +635,7 @@ async function twinCommand(args) {
         }
         else if (verb === 'credential') {
             // what is piped in, else the signed-in vault, else the repo's .env (company decision 0033: no vault required)
-            let input = process.stdin.isTTY ? '' : stdinText();
+            let input = process.stdin.isTTY ? '' : await stdinText();
             if (input.trim() === '') {
                 if (!world.twin(vendor))
                     throw new Error(`volter twin ${vendor} credential: this World has no twin "${vendor}"`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world",
-  "version": "3.0.123",
+  "version": "3.0.125",
   "description": "Run your app against a world of twins. `World` and `Repo` — one method per verb: init, up, run, log, diff, reset, branch, checkout, clone, fetch, changeset, push — and the `volter` command, one client of them.",
   "keywords": [
     "volter",
@@ -30,12 +30,12 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.1",
-    "@volter/world-core": "3.0.123",
-    "@volter/world-runtime": "3.0.123",
+    "@volter/world-core": "3.0.125",
+    "@volter/world-runtime": "3.0.125",
     "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "@volter/world-console": "3.0.118"
+    "@volter/world-console": "3.0.120"
   },
   "peerDependenciesMeta": {
     "@volter/world-console": {
@@ -43,7 +43,7 @@
     }
   },
   "devDependencies": {
-    "@volter/world-console": "3.0.118"
+    "@volter/world-console": "3.0.120"
   },
   "bin": {
     "volter": "dist/src/cli.js"

package/src/cli.ts

@@ -124,10 +124,18 @@ async function passthrough(cmd: string[], cwd = process.cwd()): Promise<number>
   for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP'] as const) process.on(signal, forward(signal));
   return await new Promise<number>((resolve, reject) => { child.once('error', reject); child.once('exit', (code, signal) => resolve(code ?? (signal ? 128 : 1))); });
 }
-/** All of stdin, as text: a synchronous read of fd 0 to EOF — the same on Bun and Node, and it
- *  holds the process (an async iteration of `process.stdin` here let Bun exit 0 mid-read, the
- *  credential unsealed and nothing said — found by the deploy-from-a-shared-world page). */
-function stdinText(): string { try { return readFileSync(0, 'utf8'); } catch { return ''; } }
+/** Read through EOF, including a delayed pipe producer. Bun's stdin iteration can leave the
+ *  event loop unreferenced; the timer holds it until EOF or error and is released in either case. */
+async function stdinText(): Promise<string> {
+  const keepAlive = setInterval(() => {}, 1000);
+  try {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+  } finally {
+    clearInterval(keepAlive);
+  }
+}
 
 async function worldCommand(verb: string, args: string[]): Promise<void> {
   const worldDir = value(args, '--world');
@@ -454,7 +462,7 @@ async function twinCommand(args: string[]): Promise<void> {
       world.setTwinRoot(vendor, { url, deploy, ...(value(rest, '--scope') ? { scope: value(rest, '--scope')! } : {}), ...(Object.keys(refresh).length ? { refresh } : {}) });
     } else if (verb === 'credential') {
       // what is piped in, else the signed-in vault, else the repo's .env (company decision 0033: no vault required)
-      let input = process.stdin.isTTY ? '' : stdinText();
+      let input = process.stdin.isTTY ? '' : await stdinText();
       if (input.trim() === '') {
         if (!world.twin(vendor)) throw new Error(`volter twin ${vendor} credential: this World has no twin "${vendor}"`);
         const found = await world.rootCredentialInput(vendor);

package/src/journeys/tutorial.ts

@@ -136,7 +136,7 @@ const DONE = '__VOLTER_STEP_DONE__';
 
 /**
  * Run a tutorial's steps in one bash session in the app, checking each expected line. Returns
- * every step's result; `failures()` says which steps the page got wrong.
+ * each executed step's result, stopping at the first failure; `failures()` names it.
  */
 export async function runTutorial(tutorial: Tutorial, app: { dir: string; parent: string; env: Record<string, string> }, opts: { stepTimeoutMs?: number; onStep?: (r: StepResult) => void } = {}): Promise<StepResult[]> {
   const shell = Bun.spawn({ cmd: ['bash', '--noprofile', '--norc'], cwd: app.dir, env: app.env, stdin: 'pipe', stdout: 'pipe', stderr: 'pipe', windowsHide: true });
@@ -275,6 +275,7 @@ export async function runTutorial(tutorial: Tutorial, app: { dir: string; parent
       const r: StepResult = { step, output: step.expect.length ? (fenceOutput.get(step.fence) ?? output) : output, missing, exit };
       recordDescendants();
       results.push(r); opts.onStep?.(r);
+      if (failures([r]).length) break;
     }
   } finally {
     await cleanupShell();
@@ -420,10 +421,10 @@ export function packagesNamedIn(files: string[]): string[] {
 export const TUTORIALS_DIR = resolve(import.meta.dir, '..', '..', '..', '..', 'docs');
 /** Every tutorial page: getting-started, then the guides. */
 export function tutorialFiles(): string[] {
-  const { readdirSync } = require('node:fs') as typeof import('node:fs');
-  const guides = readdirSync(join(TUTORIALS_DIR, 'guides')).filter((f) => f.endsWith('.md')).sort().map((f) => join(TUTORIALS_DIR, 'guides', f));
+  const { readdirSync, readFileSync } = require('node:fs') as typeof import('node:fs');
+  const guides = readdirSync(join(TUTORIALS_DIR, 'guides')).filter((f) => f.endsWith('.md')).sort().map((f) => join(TUTORIALS_DIR, 'guides', f))
+    .filter((file) => { const text = readFileSync(file, 'utf8'); return text.includes('<!-- journey -->') || parseTutorial(text, file).steps.some((step) => step.kind === 'file'); });
   // a cookbook page is a journey too when it says so (`<!-- journey -->`): the same runner, the same proof
-  const { readFileSync } = require('node:fs') as typeof import('node:fs');
   const cookbook = join(TUTORIALS_DIR, '..', 'cookbook');
   const recipes = readdirSync(cookbook, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(cookbook, e.name, 'README.md')).filter((f) => { try { return readFileSync(f, 'utf8').includes('<!-- journey -->'); } catch { return false; } }).sort();
   return [join(TUTORIALS_DIR, 'getting-started.md'), ...guides, ...recipes];

package/src/journeys/tutorials.test.ts

@@ -8,13 +8,19 @@ import { relative } from 'node:path';
 import { failures, packagesNamedIn, parseTutorial, removeTutorialApp, runTutorial, tutorialApp, tutorialFiles, TUTORIALS_DIR } from './tutorial.ts';
 import { startRegistry, type Registry } from '../../../../scripts/registry.ts';
 
-const only = process.env.TUTORIAL;
-const pages = tutorialFiles().filter((f) => !only || f.endsWith(`${only}.md`));
+const only = process.env.TUTORIAL?.split(',').map((name) => name.trim()).filter(Boolean);
+const matches = (file: string, name: string): boolean => file.endsWith(`/${name}.md`) || file.endsWith(`/${name}/README.md`);
+const available = tutorialFiles();
+for (const name of only ?? []) if (!available.some((file) => matches(file, name))) throw new Error(`No executable tutorial named ${name}`);
+const pages = available.filter((file) => !only?.length || only.some((name) => matches(file, name)));
 
 // one registry for the whole file: this checkout's packages, published to a registry on this
 // machine, so every page's `bun add` is a real install
 let registry: Registry | null = null;
-beforeAll(async () => { registry = await startRegistry({ only: packagesNamedIn(pages) }); }, 300_000);
+beforeAll(async () => {
+  registry = await startRegistry({ only: packagesNamedIn(pages) });
+  console.error(`prepared tutorial packages: ${JSON.stringify(registry.prepared)}`);
+}, 300_000);
 afterAll(() => { registry?.stop(); });
 
 for (const file of pages) {
@@ -38,7 +44,7 @@ for (const file of pages) {
         // a page about self-hosting the platform brings its own identity provider: the values its provider gives back (scripts/issuer-stack.ts)
         const platformOrigin = needsIssuer(readFileSync(file, 'utf8'));
         if (platformOrigin) { issuer = await startIssuer(platformOrigin); Object.assign(app.env, issuer.env); }
-        results = await runTutorial(tutorial, app, { stepTimeoutMs: 180_000, ...(trace ? { onStep: trace } : {}) }); completed = true;
+        results = await runTutorial(tutorial, app, { stepTimeoutMs: 180_000, ...(trace ? { onStep: trace } : {}) }); completed = failures(results).length === 0;
       } finally {
         // each stack is stopped whatever the other or the page did; a stop's failure is said, never in place of the page's own
         const stopped = await Promise.allSettled([hosted?.stop(), issuer?.stop()]);