@volter/world-runtime 2.0.0

package/src/up-task.ts

@@ -0,0 +1,45 @@
+import { offSignal } from './signals.ts';
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { siblingScript } from './sibling.ts';
+import type { UpWorldOptions } from './runtime.ts';
+import type { WorldInstance } from './schema.ts';
+
+export type UpTaskRequest = { type: 'start'; configId: string; options: UpWorldOptions };
+export type UpTaskReply = { instance: WorldInstance } | { error: string };
+
+/** `up` from the CLI: the boot runs in an owner process outside the caller's process group (the shape of `run`'s
+ *  task owner, ./run-task.ts), so the boot does not depend on the caller's terminal. The caller's Ctrl-C or SIGTERM
+ *  cancels the boot, which rolls back; losing the caller (its terminal closed, the caller killed) does not: a World
+ *  is not the caller's to keep, so the boot completes and its outcome is written to the lifecycle log. */
+export function superviseWorldUp(configId: string, options: UpWorldOptions): Promise<WorldInstance> {
+  return new Promise((done, reject) => {
+    const child = spawn(process.execPath, [siblingScript(import.meta.url, 'up-task-worker')], {
+      cwd: process.cwd(), env: process.env, detached: process.platform !== 'win32',
+      stdio: ['ignore', 'inherit', 'inherit', 'ipc'], serialization: 'json',
+    });
+    let reply: UpTaskReply | undefined;
+    let failure: Error | undefined;
+    const cancel = (signal: 'SIGINT' | 'SIGTERM') => {
+      if (child.connected) child.send({ type: 'cancel', signal }, error => { if (error) failure ??= error; });
+    };
+    const onInt = () => cancel('SIGINT');
+    const onTerm = () => cancel('SIGTERM');
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
+    child.on('error', error => { failure = error; });
+    child.on('message', message => { reply = message as UpTaskReply; });
+    child.once('spawn', () => {
+      const request: UpTaskRequest = { type: 'start', configId, options: { ...options, root: resolve(options.root ?? process.cwd()) } };
+      child.send(request, error => { if (error) { failure = error; if (child.connected) child.disconnect(); } });
+    });
+    child.once('close', (code, signal) => {
+      offSignal('SIGINT', onInt);
+      offSignal('SIGTERM', onTerm);
+      if (failure) reject(failure);
+      else if (reply && 'error' in reply) reject(new Error(reply.error));
+      else if (reply && code === 0) done(reply.instance);
+      else reject(new Error(`World boot owner exited without a result (${signal ?? code}); inspect \`volter-world status\` and the lifecycle log`));
+    });
+  });
+}

package/src/websocket-relay.ts

@@ -0,0 +1,32 @@
+import type { ServeHttpOptions } from '@volter/world-core';
+
+/** A message relay for the World's TLS fronts. Transport state is connection-local. */
+export function websocketRelay(targetFor: (request: Request) => string | undefined): NonNullable<ServeHttpOptions['upgrade']> {
+  type Peer = Parameters<NonNullable<ServeHttpOptions['upgrade']>['open']>[0];
+  const sessions = new WeakMap<Peer, { upstream: WebSocket; pending: Array<string | Uint8Array> }>();
+  return {
+    accepts: request => targetFor(request) !== undefined,
+    open(peer, request) {
+      const target = targetFor(request);
+      if (!target) { peer.close(1011, 'no twin for request'); return; }
+      const upstream = new WebSocket(target);
+      upstream.binaryType = 'arraybuffer';
+      const session = { upstream, pending: [] as Array<string | Uint8Array> };
+      sessions.set(peer, session);
+      upstream.onopen = () => { for (const message of session.pending) upstream.send(message); session.pending.length = 0; };
+      upstream.onmessage = event => { peer.send(typeof event.data === 'string' ? event.data : new Uint8Array(event.data as ArrayBuffer)); };
+      upstream.onclose = event => { peer.close(event.code === 1006 ? 1011 : event.code, event.reason); };
+      upstream.onerror = () => { peer.close(1011, 'twin websocket error'); };
+    },
+    message(peer, data) {
+      const session = sessions.get(peer);
+      if (!session) return;
+      if (session.upstream.readyState === WebSocket.OPEN) session.upstream.send(data); else session.pending.push(data);
+    },
+    close(peer) {
+      const session = sessions.get(peer);
+      sessions.delete(peer);
+      if (session) { session.pending.length = 0; session.upstream.close(); }
+    },
+  };
+}