@neta-art/cohub-cli 10.2.0 → 10.4.1

package/dist/commands/boards/authoring.js

@@ -1,6 +1,6 @@
 import { readBoardJsonObject } from "../../board-command-support.js";
 import { loadBoardDocument, resolveBundledFonts } from "../../board-export.js";
-import { boardPathTrack, boardSequencePatch, buildBoardScene, createBoardAnimationSampler, createNodeBoardRenderer, inspectBoardScene, measureBoardText, } from "../../board-kernel.js";
+import { boardPathTrack, boardSequencePatch, buildBoardScene, createBoardAnimationSampler, createNodeBoardRenderer, inspectBoardItems, } from "../../board-kernel.js";
 import { parseBoardTimes } from "../../board-time.js";
 import { handleHttp, json as outJson } from "../../output.js";
 import { resolveSpace } from "../../space.js";
@@ -9,9 +9,14 @@ export function registerBoardAuthoringCommands(boards) {
         .command("inspect <board>")
         .description("Measure items and report visible layout hints without changing the Board")
         .option("--animation <id>", "Animation to sample")
-        .option("--at <times>", "Time, comma-separated times, or start:end:step", "0")
+        .option("--at <times>", "Time, comma-separated times, or start:end:step (up to 100 samples)", "0")
         .option("--items <ids>", "Limit measurements to comma-separated item ids")
         .option("--json", "Output as JSON")
+        .addHelpText("after", `
+Without --animation, inspects the static document, not playback.
+Bounds use world units with x/y at the top left; worldBounds includes rotation.
+Checks native layout only, not camera cropping or content drawn inside scripts.
+Example: cohub boards inspect lesson.board --animation lecture --at 0:20s:1s --json`)
         .action(async (target, options) => {
         try {
             const { document } = await loadBoardDocument(await resolveSpace(boards), target);
@@ -21,20 +26,13 @@ export function registerBoardAuthoringCommands(boards) {
             try {
                 const ids = options.items ? new Set(options.items.split(",")) : null;
                 outJson({
-                    samples: times.map((time) => {
-                        const scene = sampler?.at(time).scene ?? buildBoardScene(document);
-                        return {
-                            time,
-                            diagnostics: inspectBoardScene(scene),
-                            items: scene.items
-                                .filter((item) => !ids || ids.has(item.id))
-                                .map((item) => ({
-                                id: item.id,
-                                bounds: item.frame,
-                                ...(item.type === "text" ? { text: measureBoardText(item.props) } : {}),
-                            })),
-                        };
-                    }),
+                    mode: sampler ? "animation" : "static",
+                    animation: options.animation ?? null,
+                    coverage: "Native layout in world coordinates; excludes camera cropping and script-drawn content.",
+                    samples: times.map((time) => ({
+                        time,
+                        ...inspectBoardItems(sampler?.at(time).scene ?? buildBoardScene(document), ids ?? undefined),
+                    })),
                 });
             }
             finally {

package/dist/commands/boards.d.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 import { parseBoardJsonObject } from "../board-command-support.js";
 export declare const parseJsonObject: typeof parseBoardJsonObject;
+export declare function boardSchemaField(schema: Record<string, unknown> | undefined, path: string): unknown;
 export declare function parseRect(value: string, name?: string): {
     x: number;
     y: number;

package/dist/commands/boards.js

@@ -2,8 +2,9 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
+import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_API, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
 import { BOARD_CREATE_INPUT_MAX_BYTES, BOARD_TRANSACTION_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, resolveBoardId, writeBoardOutput, } from "../board-command-support.js";
+import { BOARD_EXPORT_IMAGE_MEMORY_MIB } from "../board-export-resources.js";
 import { formatBoardTime, parseBoardTime, parseBoardTimes } from "../board-time.js";
 import { createClient, createRealtimeClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
@@ -11,6 +12,16 @@ import { resolveSpace } from "../space.js";
 import { registerBoardExampleCommands } from "./boards/examples.js";
 import { registerBoardAuthoringCommands } from "./boards/authoring.js";
 export const parseJsonObject = parseBoardJsonObject;
+export function boardSchemaField(schema, path) {
+    let field = schema;
+    for (const part of path.split(".")) {
+        const properties = field?.properties;
+        if (!part || !properties || !Object.hasOwn(properties, part))
+            throw new Error(`Unknown schema field ${path}.`);
+        field = properties[part];
+    }
+    return field;
+}
 function withJson(command) {
     return command.option("--json", "Output as JSON");
 }
@@ -152,6 +163,7 @@ function registerExportCommand(boards) {
         .option("--format <format>", `Override the format (${BOARD_EXPORT_FORMATS.join(", ")}, ${BOARD_VIDEO_FORMATS.join(", ")})`)
         .option("--quality <q>", "JPEG/WebP quality from 0 to 1", "0.92")
         .option("--fps <rate>", "Video frame rate; defaults to the --at step")
+        .option("--image-memory <mib>", "Decoded image memory budget in MiB", String(BOARD_EXPORT_IMAGE_MEMORY_MIB))
         .option("--no-images", "Draw placeholders instead of downloading images")
         .option("--force", "Replace existing output files"))
         .addHelpText("after", `
@@ -180,6 +192,11 @@ Examples:
                 if (!jsonRequested(options) && (completed === total || completed % 30 === 0))
                     process.stderr.write(`Rendered ${completed}/${total} frames\n`);
             };
+            const imageMemoryMiB = parseNumber(options.imageMemory ?? String(BOARD_EXPORT_IMAGE_MEMORY_MIB), "--image-memory", { min: 1, max: 65536, integer: true });
+            const onPlan = ({ width, height, frames }) => {
+                if (!jsonRequested(options))
+                    process.stderr.write(`Rendering ${width}x${height}, ${frames} frame(s)\n`);
+            };
             const pathVideoFormat = videoFormatFromPath(out);
             const requestedFormat = options.format?.toLowerCase();
             if (requestedFormat && ![...BOARD_EXPORT_FORMATS, ...BOARD_VIDEO_FORMATS].includes(requestedFormat))
@@ -204,6 +221,8 @@ Examples:
                     target,
                     camera,
                     onProgress: progress,
+                    onPlan,
+                    imageMemoryMiB,
                     signal: controller.signal,
                     force: options.force,
                     region: parseExportRegion(options),
@@ -238,6 +257,8 @@ Examples:
                 target,
                 camera,
                 onProgress: progress,
+                onPlan,
+                imageMemoryMiB,
                 signal: controller.signal,
                 onFrame: async (frame, index) => {
                     const path = sequence ? framePath(out, index) : out;
@@ -283,13 +304,18 @@ export function registerBoards(program) {
         .description("Read, write, animate and export Boards (by id or .board path)")
         .addHelpText("after", `
 A Board is one JSON document: { board, items, animations }.
-  get      read it
-  apply    write it with a JSON Merge Patch; null deletes
-  schema   the schema of any part, and what tracks can animate
-  preset   tracks for a preset motion, ready to apply
-  history  list versions, or restore one
-  export   render an image, a frame sequence or a video
-  examples starter documents
+  get       read it
+  apply     write it with a JSON Merge Patch; null deletes
+  schema    the fields of any part and what they mean; also the script API
+  examples  starter documents and a custom script module
+  preset    tracks for a preset motion, ready to apply
+  sequence  join chapter animations into one timeline
+  path      sample a polyline into a position track
+  inspect   measure items and report layout hints
+  export    render an image, a frame sequence or a video
+  play      shared playback; also pause, resume, next, seek, stop
+  watch     stream changes and playback
+  history   list versions, or restore one
 Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
     withJson(boards.command("create <path>")
         .description("Create a Board file, optionally with an initial document")
@@ -443,18 +469,23 @@ Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
     });
     boards.command("schema [target]")
         .description("Print JSON Schema for a part of a Board")
+        .option("--field <path>", "Print one field, e.g. props.decoration or props.geometry")
         .addHelpText("after", `
-With a target: one item type, or animation, track, or camera.
-Targets: ${BOARD_SCHEMA_TARGETS.join(", ")}
-Without a target: units, item types, colors and every animatable property.`)
-        .action((target) => {
+Without a target: units, item types, colors and every animatable property.
+With a target: its fields and what they mean; script also lists the module API.
+Targets: ${BOARD_SCHEMA_TARGETS.join(", ")}`)
+        .action((target, options) => {
         try {
+            if (options.field && !target)
+                throw new Error("--field needs a schema target, e.g. schema frame --field props.decoration.");
             if (!target)
                 return outJson({ ...boardSchemaOverview(), presets: listBoardPresets() });
             const schema = boardJsonSchema(target);
             if (!schema)
                 throw new Error(`Unknown target ${target}; expected ${BOARD_SCHEMA_TARGETS.join(", ")}.`);
-            outJson(schema);
+            if (options.field)
+                return outJson(boardSchemaField(schema.schema, options.field));
+            outJson(target === "script" ? { ...schema, api: BOARD_SCRIPT_API } : schema);
         }
         catch (cause) {
             handleHttp(cause);

package/dist/commands/rooms-connect.d.ts

@@ -0,0 +1,17 @@
+import type { Readable } from "node:stream";
+type Input = {
+    op: "publish" | "send";
+    type: string;
+    data: unknown;
+} | {
+    op: "presence";
+    presence: Record<string, unknown> | null;
+};
+export declare function parseRoomInput(line: string): Input;
+export declare function readRoomLines(input: Readable, maxBytes?: number): AsyncGenerator<string>;
+export declare function connectToRoom(roomId: string, options: {
+    after?: string;
+    input?: boolean;
+    json: boolean;
+}): Promise<void>;
+export {};

package/dist/commands/rooms-connect.js

@@ -0,0 +1,140 @@
+import { createRealtimeClient } from "../client.js";
+const MAX_LINE_BYTES = 20 * 1024;
+const MAX_OUTPUT_BUFFER_BYTES = 1024 * 1024;
+export function parseRoomInput(line) {
+    if (Buffer.byteLength(line) > MAX_LINE_BYTES)
+        throw new Error("Room input line is too large");
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        throw new Error("Room input must be JSON");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Room input must be an object");
+    const input = value;
+    if (input.op === "presence" && (input.presence === null || typeof input.presence === "object" && !Array.isArray(input.presence))) {
+        return { op: "presence", presence: input.presence };
+    }
+    if ((input.op === "publish" || input.op === "send") && typeof input.type === "string" && "data" in input) {
+        return { op: input.op, type: input.type, data: input.data };
+    }
+    throw new Error("Use {\"op\":\"publish|send\",\"type\":\"name\",\"data\":...} or {\"op\":\"presence\",\"presence\":...}");
+}
+export async function* readRoomLines(input, maxBytes = MAX_LINE_BYTES) {
+    let pending = Buffer.alloc(0);
+    for await (const chunk of input) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        let start = 0;
+        for (;;) {
+            const end = bytes.indexOf(10, start);
+            const part = bytes.subarray(start, end < 0 ? bytes.length : end);
+            if (pending.length + part.length > maxBytes)
+                throw new Error("Room input line is too large");
+            pending = pending.length ? Buffer.concat([pending, part]) : part;
+            if (end < 0)
+                break;
+            yield pending.toString("utf8").replace(/\r$/, "");
+            pending = Buffer.alloc(0);
+            start = end + 1;
+        }
+    }
+    if (pending.length)
+        yield pending.toString("utf8");
+}
+export async function connectToRoom(roomId, options) {
+    const after = options.after === undefined ? undefined : Number(options.after);
+    if (after !== undefined && (!Number.isSafeInteger(after) || after < 0))
+        throw new Error("--after must be a non-negative sequence number");
+    const client = createRealtimeClient();
+    let room = null;
+    let stopped = false;
+    let finish;
+    const done = new Promise((resolve) => { finish = resolve; });
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        finish();
+    };
+    const write = (kind, value) => {
+        if (stopped)
+            return;
+        if (process.stdout.writableLength > MAX_OUTPUT_BUFFER_BYTES) {
+            process.stderr.write("Room output is too slow; disconnecting.\n");
+            process.exitCode = 1;
+            stop();
+            return;
+        }
+        process.stdout.write(options.json ? `${JSON.stringify({ kind, ...value })}\n` : `${kind}: ${JSON.stringify(value)}\n`);
+    };
+    const onSignal = () => { stop(); void room?.disconnect().catch(() => undefined); void client.disconnect(); };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    let inputTask = null;
+    try {
+        room = await client.rooms.connect(roomId, {
+            after,
+            onRoom: (active) => {
+                room = active;
+                if (stopped) {
+                    void active.disconnect();
+                    return;
+                }
+                active.subscribeAll((event) => write("event", { event }));
+                active.onMembersChanged((members) => write("members", { members }));
+                active.onOutOfSync((from, to) => write("gap", { from, to }));
+                active.onSendError((failure) => write("error", { message: failure.message }));
+                active.onStateChange((state) => {
+                    write("state", { state });
+                    if (state === "closed" || state === "expired")
+                        stop();
+                });
+            },
+        });
+        if (!stopped)
+            write("connected", { roomId, participantId: room.participantId, sequence: room.sequence });
+        if (!stopped && options.input) {
+            const active = room;
+            inputTask = (async () => {
+                let lineNumber = 0;
+                for await (const line of readRoomLines(process.stdin)) {
+                    if (stopped)
+                        break;
+                    lineNumber++;
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const input = parseRoomInput(line);
+                        if (input.op === "presence")
+                            await active.setPresence(input.presence);
+                        else if (input.op === "send")
+                            active.send(input.type, input.data);
+                        else {
+                            const result = await active.publish(input.type, input.data);
+                            write("ack", { line: lineNumber, sequence: result.sequence, eventId: result.eventId });
+                        }
+                    }
+                    catch (cause) {
+                        write("input_error", { line: lineNumber, message: cause instanceof Error ? cause.message : String(cause) });
+                    }
+                }
+            })().catch((cause) => {
+                write("input_error", { message: cause instanceof Error ? cause.message : String(cause) });
+                process.exitCode = 1;
+                stop();
+            });
+        }
+        await done;
+    }
+    finally {
+        if (options.input)
+            process.stdin.destroy();
+        await room?.disconnect().catch(() => undefined);
+        await client.disconnect();
+        await inputTask?.catch(() => undefined);
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+    }
+}

package/dist/commands/rooms-rtc-binary.d.ts

@@ -0,0 +1,2 @@
+export declare const RTC_HELPER_VERSION: string;
+export declare function ensureRtcBinary(local?: string): Promise<string>;

package/dist/commands/rooms-rtc-binary.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+// Pin a global release tag after its helper artifacts are published.
+export const RTC_HELPER_VERSION = "v2.67.0";
+const MAX_BINARY_BYTES = 128 * 1024 * 1024;
+async function digest(path) {
+    const hash = createHash("sha256");
+    await pipeline(createReadStream(path), hash);
+    return hash.digest("hex");
+}
+async function readText(response, limit) {
+    if (!response.body)
+        throw new Error("Empty RTC helper response");
+    const reader = response.body.getReader();
+    const parts = [];
+    let bytes = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            bytes += value.length;
+            if (bytes > limit)
+                throw new Error("RTC helper metadata exceeds the size limit");
+            parts.push(value);
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    return Buffer.concat(parts).toString("utf8");
+}
+export async function ensureRtcBinary(local) {
+    const override = local || process.env.COHUB_RTC_BIN?.trim();
+    if (override) {
+        if (!(await lstat(override)).isFile())
+            throw new Error("RTC helper must be a regular file");
+        return resolve(override);
+    }
+    const platform = { linux: "linux", darwin: "darwin" }[process.platform];
+    const arch = { x64: "amd64", arm64: "arm64" }[process.arch];
+    if (!platform || !arch)
+        throw new Error("Unsupported RTC helper platform; use --helper with a local binary");
+    const version = process.env.COHUB_RTC_VERSION?.trim() || RTC_HELPER_VERSION;
+    if (!version)
+        throw new Error("No RTC helper release is pinned yet; use --helper or COHUB_RTC_VERSION with a published global release");
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(version))
+        throw new Error("Invalid RTC helper version");
+    const directory = join(homedir(), ".cache", "cohub", "rtc", version, `${platform}-${arch}`);
+    const binary = join(directory, "cohub-rtc");
+    const checksum = `${binary}.sha256`;
+    const expected = await readFile(checksum, "utf8").catch(() => "");
+    if (/^[a-f0-9]{64}$/.test(expected) && (await lstat(binary).catch(() => null))?.isFile() && await digest(binary) === expected)
+        return binary;
+    await mkdir(directory, { recursive: true });
+    const temporary = await mkdtemp(join(directory, ".download-"));
+    const base = (process.env.COHUB_RTC_CDN_BASE_URL?.trim() || "https://public.cohub.live/rtc").replace(/\/+$/, "");
+    const url = `${base}/${version}/cohub-rtc_${platform}_${arch}.gz`;
+    const signal = AbortSignal.timeout(120_000);
+    try {
+        const manifest = await fetch(`${url}.sha256`, { signal });
+        if (!manifest.ok)
+            throw new Error(`RTC helper ${version} is unavailable (${manifest.status}); use --helper with a locally built cohub-rtc`);
+        const text = await readText(manifest, 1024);
+        const expectedArchive = text.trim().split(/\s+/)[0];
+        if (!expectedArchive || !/^[a-f0-9]{64}$/.test(expectedArchive))
+            throw new Error("Invalid RTC helper checksum");
+        const response = await fetch(url, { signal });
+        if (!response.ok || !response.body)
+            throw new Error(`RTC helper download failed (${response.status})`);
+        let bytes = 0;
+        const bound = () => new Transform({ transform(chunk, _encoding, done) {
+                bytes += chunk.length;
+                done(bytes > MAX_BINARY_BYTES ? new Error("RTC helper exceeds the size limit") : null, chunk);
+            } });
+        const archive = join(temporary, "archive.gz");
+        await pipeline(Readable.fromWeb(response.body), bound(), createWriteStream(archive, { flags: "wx" }), { signal });
+        if (await digest(archive) !== expectedArchive)
+            throw new Error("RTC helper checksum mismatch");
+        for (const name of ["LICENSE", "NOTICE"]) {
+            const response = await fetch(`${base}/${version}/${name}`, { signal });
+            if (!response.ok)
+                throw new Error(`RTC helper ${name} is unavailable (${response.status})`);
+            const text = await readText(response, 64 * 1024);
+            await writeFile(join(temporary, name), text, { flag: "wx" });
+            await rename(join(temporary, name), join(directory, name));
+        }
+        const extracted = join(temporary, "cohub-rtc");
+        bytes = 0;
+        await pipeline(createReadStream(archive), createGunzip(), bound(), createWriteStream(extracted, { flags: "wx", mode: 0o700 }), { signal });
+        await chmod(extracted, 0o700);
+        const hash = await digest(extracted);
+        await writeFile(join(temporary, "checksum"), hash, { flag: "wx" });
+        await rename(extracted, binary);
+        await rename(join(temporary, "checksum"), checksum);
+        return binary;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}

package/dist/commands/rooms-rtc.d.ts

@@ -0,0 +1,21 @@
+export type RtcOptions = {
+    helper?: string;
+    audio?: string;
+    video?: string;
+    audioFormat: "pcm" | "opus";
+    videoFormat: "i420" | "vp8";
+    size?: string;
+    fps: string;
+    rate: string;
+    channels: string;
+    output?: string;
+    receiveFormat: "rtp" | "raw";
+    receiveSize: string;
+    maxBytes: string;
+    participant?: string;
+    channel?: string;
+    delivery: "reliable" | "latest";
+    dataInput?: string;
+    json?: boolean;
+};
+export declare function runRoomRtc(roomId: string, options: RtcOptions): Promise<void>;

package/dist/commands/rooms-rtc.js

@@ -0,0 +1,171 @@
+import { spawn } from "node:child_process";
+import { HttpError } from "@neta-art/cohub";
+import { createRealtimeClient } from "../client.js";
+import { readRoomLines } from "./rooms-connect.js";
+import { ensureRtcBinary } from "./rooms-rtc-binary.js";
+export async function runRoomRtc(roomId, options) {
+    if (options.delivery !== "reliable" && options.delivery !== "latest")
+        throw new Error("--delivery must be reliable or latest");
+    if (options.dataInput && !options.channel)
+        throw new Error("--data-input requires --channel");
+    if ([options.audio, options.video, options.dataInput].filter((value) => value === "-").length > 1)
+        throw new Error("Only one input can use stdin");
+    const maxBytes = Number(options.maxBytes);
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+        throw new Error("--max-bytes must be a non-negative safe integer");
+    const client = createRealtimeClient();
+    const sessions = new Set();
+    const pending = new Set();
+    let room;
+    let helper;
+    let control;
+    let exit;
+    let killTimer;
+    let stopped = false;
+    let failure;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        helper?.kill("SIGTERM");
+        if (helper)
+            killTimer = setTimeout(() => helper?.kill("SIGKILL"), 5_000);
+    };
+    const fail = (cause) => { failure ??= cause; stop(); };
+    const send = (value) => {
+        if (!control || control.destroyed || stopped)
+            return;
+        const line = `${JSON.stringify(value)}\n`;
+        if (Buffer.byteLength(line) > 256 * 1024 || control.writableLength > 1024 * 1024)
+            throw new Error("RTC control input is too slow or too large");
+        control.write(line);
+    };
+    let previousMembers = "";
+    const report = (value) => {
+        const output = options.output === "-" ? process.stderr : process.stdout;
+        if (output.writableLength > 1024 * 1024)
+            throw new Error("RTC output is too slow");
+        output.write(`${JSON.stringify(value)}\n`);
+    };
+    const release = async (sessionId) => {
+        if (!sessions.has(sessionId))
+            return;
+        await client.rooms.signalRtc(roomId, { method: "DELETE", path: `/${sessionId}` });
+        sessions.delete(sessionId);
+    };
+    const request = async (message) => {
+        try {
+            if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(message.method))
+                throw new Error("Invalid RTC signaling method");
+            const opening = message.method === "POST" && message.path === "";
+            const body = await client.rooms.signalRtc(roomId, {
+                method: message.method,
+                path: message.path,
+                body: opening ? { ticket: "hosted", participantId: room?.participantId } : message.method === "GET" ? undefined : message.body,
+            });
+            if (opening && body.sessionId)
+                sessions.add(body.sessionId);
+            if (message.method === "GET" && room) {
+                const snapshot = await client.rooms.get(roomId);
+                send({ kind: "members", body: snapshot.members.map(({ participantId, publications }) => ({ participantId, publications })) });
+                previousMembers = "";
+            }
+            send({ kind: "response", id: message.id, body });
+        }
+        catch (cause) {
+            send({ kind: "response", id: message.id, error: cause instanceof Error ? cause.message : String(cause), code: cause instanceof HttpError ? cause.code : "RTC_FAILED" });
+        }
+    };
+    const track = (task) => {
+        pending.add(task);
+        void task.catch(fail).finally(() => pending.delete(task));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    process.stdout.on("error", fail);
+    process.stderr.on("error", fail);
+    try {
+        const binary = await ensureRtcBinary(options.helper);
+        if (stopped)
+            return;
+        room = await client.rooms.connect(roomId);
+        if (stopped)
+            return;
+        room.onStateChange((state) => {
+            try {
+                report({ kind: "room", state });
+            }
+            catch (cause) {
+                fail(cause);
+            }
+            if (state === "closed" || state === "expired")
+                stop();
+        });
+        helper = spawn(binary, [], { stdio: ["inherit", "inherit", "inherit", "pipe", "pipe"] });
+        control = helper.stdio[3];
+        const events = helper.stdio[4];
+        control.on("error", fail);
+        exit = new Promise((resolve, reject) => {
+            helper?.once("error", reject);
+            helper?.once("close", (code, signal) => {
+                if (killTimer)
+                    clearTimeout(killTimer);
+                if (code === 0 || stopped && signal === "SIGTERM")
+                    resolve();
+                else
+                    reject(new Error(`RTC helper exited with ${signal ?? code}`));
+            });
+        });
+        void exit.catch(fail);
+        send({ protocol: 1, ...options, maxBytes, participantId: room.participantId });
+        const updateMembers = () => {
+            const body = room?.members.map(({ participantId, publications }) => ({ participantId, publications }));
+            const next = JSON.stringify(body);
+            if (next === previousMembers)
+                return;
+            send({ kind: "members", body });
+            previousMembers = next;
+        };
+        room.onMembersChanged(() => { try {
+            updateMembers();
+        }
+        catch (cause) {
+            fail(cause);
+        } });
+        updateMembers();
+        report({ kind: "connected", roomId, participantId: room.participantId });
+        for await (const line of readRoomLines(events, 256 * 1024)) {
+            const message = JSON.parse(line);
+            if (message.kind === "request") {
+                if (pending.size >= 16)
+                    throw new Error("Too many pending RTC requests");
+                track(request(message));
+            }
+            else if (message.kind === "release") {
+                await release(message.sessionId);
+            }
+            else
+                report(message);
+        }
+        await exit;
+    }
+    finally {
+        stop();
+        await exit?.catch((cause) => { failure ??= cause; });
+        if (killTimer)
+            clearTimeout(killTimer);
+        await Promise.allSettled(pending);
+        const results = await Promise.allSettled([...sessions].map(release));
+        for (const result of results)
+            if (result.status === "rejected")
+                failure ??= result.reason;
+        await room?.disconnect().catch((cause) => { failure ??= cause; });
+        await client.disconnect().catch((cause) => { failure ??= cause; });
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        process.stdout.removeListener("error", fail);
+        process.stderr.removeListener("error", fail);
+    }
+    if (failure)
+        throw failure;
+}