@volter/world-runtime 3.0.100 → 3.0.102

package/src/schema.ts

@@ -97,16 +97,15 @@ export type WorldExternalDiscover = {
 };
 
 /**
- * Optional readiness probe, polled after `up` until it passes or `timeoutMs` elapses. Exactly one of:
- *  - `command`/`args`: a command that must exit 0,
- *  - `httpUrl`: an HTTP(S) URL that must return a 2xx/3xx response,
- *  - `stdoutMatch`: a regex that must appear in the `up` command's captured stdout/stderr log.
+ * Optional readiness probe, polled after `up` until it passes or `timeoutMs` elapses: the service answering its own
+ * protocol (architecture D9). Exactly one of:
+ *  - `command`/`args`: a command that asks the service and exits 0 when it answers,
+ *  - `httpUrl`: an HTTP(S) URL that must return a 2xx/3xx response.
  */
 export type WorldExternalReadyWhen = {
   command?: string;
   args?: string[];
   httpUrl?: string;
-  stdoutMatch?: string;
   timeoutMs?: number;
   intervalMs?: number;
 };
@@ -224,7 +223,6 @@ export type WorldServiceConfig = {
    * service truly serves, so `up` returning means "ready" (no post-up re-polling needed):
    *   - `{ httpUrl }`  — poll until 2xx/3xx. `${url}`/`${host}`/`${port}` resolve to the allocated port.
    *   - `{ command, args }` — poll until the command exits 0 (runs with the service env, incl. `PORT`).
-   *   - `{ stdoutMatch }` — poll until a regex matches the service's stdout/stderr log.
    * 'external' services use `external.readyWhen` instead.
    */
   ready?: 'tcp' | WorldExternalReadyWhen;
@@ -461,26 +459,21 @@ function assertValidRegex(pattern: string, what: string, path: string): void {
 }
 
 /** Shared validator for a readiness probe — used by both `external.readyWhen` and a process/twin
- * service's `ready` object. Exactly one of command/httpUrl/stdoutMatch, correct types, and any
- * stdoutMatch regex must compile (so a typo fails at config time, not mid-boot). */
+ * service's `ready` object. Exactly one of command/httpUrl, with correct types. */
 function assertReadyWhen(ready: unknown, what: string, path: string): void {
   if (!ready || typeof ready !== 'object' || Array.isArray(ready)) {
     throw new Error(`${what} must be an object in ${path}`);
   }
-  assertKeys(ready as Record<string, unknown>, ['command', 'args', 'httpUrl', 'stdoutMatch', 'timeoutMs', 'intervalMs'], what, path);
+  assertKeys(ready as Record<string, unknown>, ['command', 'args', 'httpUrl', 'timeoutMs', 'intervalMs'], what, path);
   const r = ready as WorldExternalReadyWhen;
-  const probes = [r.command !== undefined, r.httpUrl !== undefined, r.stdoutMatch !== undefined].filter(Boolean).length;
+  const probes = [r.command !== undefined, r.httpUrl !== undefined].filter(Boolean).length;
   if (probes !== 1) {
-    throw new Error(`${what} must set exactly one of command/httpUrl/stdoutMatch in ${path}`);
+    throw new Error(`${what} must set exactly one of command/httpUrl in ${path}`);
   }
   if (r.command !== undefined && typeof r.command !== 'string') throw new Error(`${what}.command must be a string in ${path}`);
   if (r.args !== undefined && (!Array.isArray(r.args) || r.args.some((arg) => typeof arg !== 'string'))) throw new Error(`${what}.args must be a string array in ${path}`);
   if (r.args !== undefined && r.command === undefined) throw new Error(`${what}.args requires command in ${path}`);
   if (r.httpUrl !== undefined && typeof r.httpUrl !== 'string') throw new Error(`${what}.httpUrl must be a string in ${path}`);
-  if (r.stdoutMatch !== undefined) {
-    if (typeof r.stdoutMatch !== 'string') throw new Error(`${what}.stdoutMatch must be a string in ${path}`);
-    assertValidRegex(r.stdoutMatch, `${what}.stdoutMatch`, path);
-  }
   for (const key of ['timeoutMs', 'intervalMs'] as const) {
     if (r[key] !== undefined && (!Number.isInteger(r[key]) || r[key]! <= 0)) throw new Error(`${what}.${key} must be a positive integer in ${path}`);
   }

package/src/service-exit.ts

@@ -83,12 +83,6 @@ function split(line: string): { output: string; record?: { event?: unknown; at?:
   try { return { output: line.slice(0, at), record: JSON.parse(line.slice(at)) as { event?: unknown; at?: unknown } }; } catch { return { output: line }; }
 }
 
-/** A log's text as the service wrote it, without the recorder's records: what a `stdoutMatch` readiness pattern is
- *  matched against. */
-export function serviceOutput(text: string): string {
-  return text.includes(MARK) ? text.split('\n').map((line) => split(line).output).join('\n') : text;
-}
-
 /** The last run's end in a service log: its start, its exit record (absent while it runs, or when its parent was killed
  *  with it), and the output it wrote last. Undefined for a log the parent never wrote to (a co-located twin's host log),
  *  which has no runs to tell apart. A run is bounded by its start record or, for a spawn that failed before starting

package/src/up-cli.ts

@@ -22,7 +22,17 @@ export async function upCommand(subject: string | undefined, rest: string[], roo
   // --keep-state: boot over the state the World's directory already holds (a World carried somewhere else, e.g. a
   // browser tab's image, comes up over its data instead of starting empty, as a fresh `up` does)
   const keepState = rest.includes('--keep-state');
+  // --app-url: where the booter serves the app, recorded as `volter-world app-url --set` records it, once the World is
+  // up and in this process: a booter that knows the address before the app listens (a browser tab's preview origin)
+  // saves a whole command between up and the app's start.
+  const appUrl = optionValue(rest, '--app-url') || undefined;
+  if (appUrl !== undefined && !(URL.canParse(appUrl) && /^https?:$/.test(new URL(appUrl).protocol))) throw new Error(`volter-world up: --app-url "${appUrl}" must be an http(s) URL`);
   const instance = await superviseWorldUp(subject, { name, root, mode, envFile, forceEnvOutput: rest.includes('--force'), owner: ownerOption(rest), ...(isolation ? { isolation } : {}), ...(keepState ? { keepState: true } : {}) });
+  if (appUrl !== undefined) {
+    const { setAppUrl } = await import('./app-url.ts');
+    setAppUrl(instance.name, appUrl, { root });
+    process.stderr.write(`volter-world up ${instance.name}: app url recorded: ${appUrl}\n`);
+  }
   if (rest.includes('--json')) process.stdout.write(JSON.stringify(instance, null, 2) + '\n');
   else printReady(instance);
 }