@remavideo/sdk 0.9.0

package/dist/index.js

@@ -0,0 +1,1309 @@
+// src/input/caption-source.ts
+import { readFile } from "fs/promises";
+
+// src/node.ts
+var NODE_STATES = /* @__PURE__ */ new Set([
+  "READY",
+  "ACTIVE",
+  "ENDED",
+  "ERROR",
+  "CLOSED"
+]);
+function dispatchNodeCallbacks(evt, callbacks) {
+  if (NODE_STATES.has(evt.kind)) {
+    callbacks.onStatusChange?.(evt.kind, evt.message);
+  }
+  if (evt.kind === "ERROR") {
+    callbacks.onError?.(new Error(evt.message ?? "node error"));
+  }
+  if (evt.kind === "CLOSED") {
+    callbacks.onClose?.();
+  }
+}
+var BaseNode = class _BaseNode {
+  nodeId;
+  workflowId;
+  client;
+  _eventCleanup = null;
+  _callbacks = {};
+  constructor(nodeId, client, workflowId) {
+    this.nodeId = nodeId;
+    this.workflowId = workflowId;
+    this.client = client;
+  }
+  /** Called by create functions to register the workflow event handler cleanup. */
+  _setEventCleanup(fn) {
+    this._eventCleanup = fn;
+  }
+  /**
+   * Called by create functions to register the node's lifecycle callbacks
+   * (`onError`/`onStatusChange`/`onClose`), so `.close()` can invoke `onClose`
+   * directly on a locally-initiated close.
+   */
+  _bindCallbacks(callbacks) {
+    this._callbacks = callbacks;
+  }
+  /**
+   * Subscribe this node to one or more source nodes.
+   * This tells the server to route streams from the sources into this node.
+   */
+  async subscribe(specs, options) {
+    await this.client.trpc.subscribeNode.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      sources: specs.map((s) => _BaseNode._toSourceInput(s)),
+      gate: options?.gate
+    });
+  }
+  /** Map one `SubscriptionSpec` to the wire shape expected by the server. */
+  static _toSourceInput(spec) {
+    const base = {
+      sourceNodeId: spec.source.nodeId,
+      ...spec.delayMs !== void 0 ? { delayMs: spec.delayMs } : {},
+      ...spec.port !== void 0 ? { port: spec.port } : {},
+      ...spec.name !== void 0 ? { name: spec.name } : {}
+    };
+    const audio = (a) => ({
+      language: a.language ?? "und",
+      label: a.label ?? "Audio",
+      defaultTrack: a.defaultTrack ?? false
+    });
+    const video = (v) => v.label !== void 0 ? { video: { label: v.label } } : {};
+    switch (spec.sourceSelector) {
+      case "CAPTIONS":
+        return { ...base, selector: "CAPTIONS" };
+      case "VIDEO":
+        return {
+          ...base,
+          selector: "VIDEO",
+          ...spec.track !== void 0 ? { track: spec.track } : {},
+          ...spec.codec !== void 0 ? { codec: spec.codec } : {},
+          ...spec.video !== void 0 ? video(spec.video) : {}
+        };
+      case "AUDIO":
+        return {
+          ...base,
+          selector: "AUDIO",
+          ...spec.track !== void 0 ? { track: spec.track } : {},
+          ...spec.codec !== void 0 ? { codec: spec.codec } : {},
+          ...spec.audio !== void 0 ? { audio: audio(spec.audio) } : {}
+        };
+      case "ALL":
+        return {
+          ...base,
+          selector: "ALL",
+          ...spec.videoCodec !== void 0 ? { videoCodec: spec.videoCodec } : {},
+          ...spec.audioCodec !== void 0 ? { audioCodec: spec.audioCodec } : {},
+          ...spec.video !== void 0 ? video(spec.video) : {},
+          ...spec.audio !== void 0 ? { audio: audio(spec.audio) } : {}
+        };
+    }
+  }
+  /**
+   * Probe this node's media stream (ffprobe, server-side) and return its
+   * track list. Each entry's `track` is the per-type index to pass back as
+   * `track` in a VIDEO/AUDIO subscription:
+   *
+   * ```ts
+   * const tracks = await input.tracks();
+   * const ita = tracks.find((t) => t.type === "audio" && t.language === "ita");
+   * await output.subscribe([
+   *   { source: input, sourceSelector: "VIDEO" },
+   *   { source: input, sourceSelector: "AUDIO", track: ita!.track },
+   * ]);
+   * ```
+   *
+   * Probing consumes real-time-paced stream data, so it can take several
+   * seconds; `probeSizeBytes` (default 1 MB) trades discovery depth for
+   * latency. The server errors after ~15 s if the source produces no data
+   * (e.g. no publisher connected yet, or a disabled file input).
+   */
+  async tracks(options) {
+    return this.client.trpc.probeTracks.query({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      ...options?.probeSizeBytes !== void 0 ? { probeSizeBytes: options.probeSizeBytes } : {}
+    });
+  }
+  /** Tear down this node on the server. */
+  async close() {
+    this._eventCleanup?.();
+    await this.client.trpc.closeNode.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId
+    });
+    this._callbacks.onClose?.();
+  }
+};
+
+// src/input/caption-source.ts
+var CaptionSourceNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+  /**
+   * Queue caption text for injection into the video stream.
+   *
+   * @param options.startAt   Stream-elapsed milliseconds (relative to the
+   *                          first video frame received by the server) at which
+   *                          to show the caption.  The server holds the text and
+   *                          injects it at the matching PTS, so you can schedule
+   *                          captions before that point in the stream is reached.
+   *                          Omit (or 0) to inject immediately at the next frame.
+   * @param options.duration  How long (ms) the caption stays visible before
+   *                          being automatically erased. Required.
+   */
+  async send(text, options) {
+    await this.client.trpc.sendCaption.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      text,
+      durationMs: options.duration,
+      startAtMs: options.startAt ?? 0
+    });
+  }
+  /**
+   * Parse raw SRT or WebVTT content and schedule all entries on the server.
+   *
+   * Use `replayCount: Infinity` when creating this node if the pipeline may
+   * connect encoders after the captions are loaded.
+   *
+   * @returns The number of caption entries loaded.
+   */
+  async sendFile(content) {
+    return this.client.trpc.loadCaptionFile.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      content
+    });
+  }
+  /**
+   * Read a local SRT or WebVTT file and schedule all its entries on the server.
+   * The file is read client-side; only the content string is sent over the wire.
+   *
+   * @param filePath Absolute or relative path to the subtitle file.
+   * @returns The number of caption entries loaded.
+   */
+  async sendFileByPath(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    return this.sendFile(content);
+  }
+};
+async function createCaptionSourceNode(workflow, settings = {}, nodeId) {
+  const id = nodeId ?? `caption_source_${Date.now()}`;
+  const node = new CaptionSourceNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "CAPTION_SOURCE",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    captionSource: {
+      replayCount: settings.replayCount ?? 0,
+      language: settings.language ?? "und",
+      label: settings.label ?? "Subtitles",
+      defaultTrack: settings.defaultTrack ?? true,
+      ...settings.maxLineLength !== void 0 && {
+        maxLineLength: settings.maxLineLength
+      }
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/file.ts
+import { uid } from "radash";
+var FileInputNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+  /** Enable this node — starts reading the file and streaming to downstream nodes. */
+  async enable() {
+    await this.client.trpc.enableNode.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId
+    });
+  }
+};
+async function createFileInputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `file_input_${uid(12)}`;
+  const node = new FileInputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "READY") settings.onReady?.();
+    if (evt.kind === "ACTIVE" && evt.message !== void 0)
+      settings.onStreamStart?.(Number(evt.message));
+    if (evt.kind === "ENDED") settings.onEnded?.();
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "FILE_INPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    fileInput: {
+      fileName: settings.fileName,
+      loop: settings.loop ?? false,
+      sourceName: settings.sourceName,
+      disabled: settings.disabled ?? false
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/node-stream.ts
+import { uid as uid2 } from "radash";
+var NodeStreamInputNode = class extends BaseNode {
+  settings;
+  _apiBase;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+    const { host, port } = workflow.client.options;
+    this._apiBase = `http://${host}:${port}`;
+  }
+  /**
+   * Push an audio stream to the server.
+   *
+   * Accepts any `AsyncIterable<Buffer | Uint8Array>`, which includes Node.js
+   * `Readable` streams (async-iterable since Node 10) and async generators.
+   * The call resolves when the source iterable is exhausted or the server
+   * closes the connection.
+   *
+   * @example
+   * ```ts
+   * import { createReadStream } from "node:fs";
+   * await audioInput.stream(createReadStream("audio.mp3"));
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Raw PCM from a microphone via node-record-lpcm16
+   * const mic = recorder.start({ sampleRate: 16000, channels: 1 });
+   * await audioInput.stream(mic);
+   * ```
+   */
+  async stream(source) {
+    const url = `${this._apiBase}/api/node-stream/${this.workflowId}/${this.nodeId}`;
+    const body = new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const chunk of source) {
+            controller.enqueue(
+              chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk)
+            );
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+    await fetch(url, {
+      method: "POST",
+      body,
+      // Required for streaming request bodies in Node.js 18+ native fetch.
+      duplex: "half"
+    });
+  }
+};
+async function createNodeStreamInputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `node_stream_${uid2(12)}`;
+  const node = new NodeStreamInputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "READY") settings.onReady?.();
+    if (evt.kind === "ACTIVE" && evt.message !== void 0)
+      settings.onStreamStart?.(Number(evt.message));
+    if (evt.kind === "ENDED") settings.onEnded?.();
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "NODE_STREAM_INPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    nodeStreamInput: {
+      format: settings.format,
+      ...settings.sampleRate !== void 0 && {
+        sampleRate: settings.sampleRate
+      },
+      ...settings.channels !== void 0 && {
+        channels: settings.channels
+      },
+      audioCodec: settings.audioCodec ?? "aac",
+      ...settings.label !== void 0 && { label: settings.label }
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/rtmp-announcer.ts
+import { uid as uid3 } from "radash";
+var RtmpAnnouncerNode = class extends BaseNode {
+  /**
+   * Forcibly disconnect the connection identified by `connectionId`. Can be
+   * called at any time after the node is created — e.g. from an async
+   * moderation decision made after `onConnect` already returned.
+   */
+  async disconnectSource(connectionId) {
+    await this.client.trpc.disconnectSource.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      connectionId
+    });
+  }
+};
+async function createRtmpAnnouncerNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `rtmp_announcer_${uid3(12)}`;
+  const app = settings.app ?? "live";
+  const node = new RtmpAnnouncerNode(id, workflow.client, workflow.workflowId);
+  const operations = {
+    disconnectSource: (connectionId) => node.disconnectSource(connectionId)
+  };
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "STREAM_CONNECTED" && evt.message !== void 0) {
+      const info = JSON.parse(evt.message);
+      settings.onConnect(info, operations);
+    }
+    if (evt.kind === "STREAM_DISCONNECTED" && evt.message !== void 0) {
+      const info = JSON.parse(evt.message);
+      settings.onDisconnect?.(info);
+    }
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "RTMP_ANNOUNCER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    rtmpAnnouncer: { app }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/rtmp-multiplexer.ts
+import { uid as uid4 } from "radash";
+var RtmpStreamNode = class extends BaseNode {
+  app;
+  sourceName;
+  constructor(nodeId, client, app, sourceName, workflowId) {
+    super(nodeId, client, workflowId);
+    this.app = app;
+    this.sourceName = sourceName;
+  }
+};
+var RtmpMultiplexerNode = class extends BaseNode {
+};
+async function createRtmpMultiplexerNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `rtmp_mux_${uid4(12)}`;
+  const app = settings.app ?? "live";
+  const node = new RtmpMultiplexerNode(
+    id,
+    workflow.client,
+    workflow.workflowId
+  );
+  const activeStreams = /* @__PURE__ */ new Map();
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+    if (evt.kind === "CHILD_CREATED" && evt.message !== void 0) {
+      const { childNodeId, sourceName } = JSON.parse(evt.message);
+      Promise.resolve(settings.onConnect?.({ app, sourceName })).then(async (result) => {
+        if (result?.accept === false) {
+          await workflow.client.trpc.rejectPublisher.mutate({
+            workflowId: workflow.workflowId,
+            nodeId: id,
+            sourceName
+          }).catch((err) => {
+            console.error("[rema] rejectPublisher failed:", err);
+          });
+          return;
+        }
+        const streamNode = new RtmpStreamNode(
+          childNodeId,
+          workflow.client,
+          app,
+          sourceName,
+          workflow.workflowId
+        );
+        activeStreams.set(sourceName, streamNode);
+        await settings.onStream(streamNode);
+      }).catch((err) => {
+        console.error("[rema] onStream error:", err);
+      });
+      return;
+    }
+    if (evt.kind === "CHILD_CLOSED" && evt.message !== void 0) {
+      const { sourceName } = JSON.parse(evt.message);
+      const streamNode = activeStreams.get(sourceName);
+      activeStreams.delete(sourceName);
+      if (streamNode) {
+        Promise.resolve(settings.onStreamEnd?.(streamNode)).catch(
+          (err) => {
+            console.error("[rema] onStreamEnd error:", err);
+          }
+        );
+      }
+    }
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "RTMP_MULTIPLEXER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    rtmpMultiplexer: { app, port: 1935 }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/rtmp-reader.ts
+import { uid as uid5 } from "radash";
+var RtmpReaderNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createRtmpReaderNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `rtmp_reader_${uid5(12)}`;
+  const node = new RtmpReaderNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "READY") {
+      settings.onPublish?.({
+        app: settings.app,
+        internalUrl: evt.message ?? ""
+      });
+    }
+    if (evt.kind === "ACTIVE" && evt.message !== void 0) {
+      settings.onStreamStart?.(Number(evt.message));
+    }
+    if (evt.kind === "ENDED") settings.onStreamEnded?.();
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "RTMP_READER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    rtmpReader: { app: settings.app, sourceName: settings.sourceName }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/srt-announcer.ts
+import { uid as uid6 } from "radash";
+var SrtAnnouncerNode = class extends BaseNode {
+  /**
+   * Forcibly disconnect the connection identified by `connectionId`. Can be
+   * called at any time after the node is created — e.g. from an async
+   * moderation decision made after `onConnect` already returned.
+   */
+  async disconnectSource(connectionId) {
+    await this.client.trpc.disconnectSource.mutate({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId,
+      connectionId
+    });
+  }
+};
+async function createSrtAnnouncerNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `srt_announcer_${uid6(12)}`;
+  const app = settings.app ?? "live";
+  const node = new SrtAnnouncerNode(id, workflow.client, workflow.workflowId);
+  const operations = {
+    disconnectSource: (connectionId) => node.disconnectSource(connectionId)
+  };
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "STREAM_CONNECTED" && evt.message !== void 0) {
+      const info = JSON.parse(evt.message);
+      settings.onConnect(info, operations);
+    }
+    if (evt.kind === "STREAM_DISCONNECTED" && evt.message !== void 0) {
+      const info = JSON.parse(evt.message);
+      settings.onDisconnect?.(info);
+    }
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "SRT_ANNOUNCER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    srtAnnouncer: {
+      app,
+      ...settings.passphrase !== void 0 && {
+        passphrase: settings.passphrase
+      },
+      ...settings.latencyMs !== void 0 && {
+        latencyMs: settings.latencyMs
+      }
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/input/srt-reader.ts
+import { uid as uid7 } from "radash";
+var SrtReaderNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createSrtReaderNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `srt_reader_${uid7(12)}`;
+  const node = new SrtReaderNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    if (evt.kind === "READY") {
+      settings.onPublish?.({
+        app: settings.app,
+        internalUrl: evt.message ?? ""
+      });
+    }
+    if (evt.kind === "ACTIVE" && evt.message !== void 0) {
+      settings.onStreamStart?.(Number(evt.message));
+    }
+    if (evt.kind === "ENDED") settings.onStreamEnded?.();
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "SRT_READER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    srtReader: { app: settings.app, sourceName: settings.sourceName }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/output/file.ts
+import { uid as uid8 } from "radash";
+var FileOutputNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createFileOutputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `file_output_${uid8(12)}`;
+  const node = new FileOutputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "FILE_OUTPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    fileOutput: {
+      fileName: settings.fileName,
+      format: settings.format ?? "",
+      overwrite: settings.overwrite ?? true
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/output/hls.ts
+import { uid as uid9 } from "radash";
+var HlsOutputNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+  /**
+   * Return the effective base path or URL for each configured destination in
+   * the current session.  Must be called after `subscribe()` so that the server
+   * has wired the destinations.  For S3 destinations this includes the
+   * per-session subfolder appended by `makePrefixUnique`.
+   */
+  async effectivePaths() {
+    const result = await this.client.trpc.hlsOutputInfo.query({
+      workflowId: this.workflowId,
+      nodeId: this.nodeId
+    });
+    return result.effectivePaths;
+  }
+};
+async function createHlsOutputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `hls_output_${uid9(12)}`;
+  const node = new HlsOutputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "HLS_OUTPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    hlsOutput: {
+      destinations: settings.destinations,
+      segmentTime: settings.segmentTime ?? 6,
+      listSize: settings.listSize ?? 5,
+      audioCodec: settings.audioCodec ?? void 0,
+      videoCodec: settings.videoCodec ?? void 0
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/output/rtmp.ts
+import { uid as uid10 } from "radash";
+var RtmpOutputNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createRtmpOutputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `rtmp_output_${uid10(12)}`;
+  const node = new RtmpOutputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "RTMP_OUTPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    rtmpOutput: { url: settings.url }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/output/srt.ts
+import { uid as uid11 } from "radash";
+var SrtOutputNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createSrtOutputNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `srt_output_${uid11(12)}`;
+  const node = new SrtOutputNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "SRT_OUTPUT",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    srtOutput: { url: settings.url }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/buffer.ts
+import { uid as uid12 } from "radash";
+var BufferNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createBufferNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `buffer_${uid12(12)}`;
+  const node = new BufferNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "BUFFER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    buffer: { bufferMs: settings.bufferMs }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/camb-ai-translate.ts
+import { uid as uid13 } from "radash";
+var CambAiTranslateNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createCambAiTranslateNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `camb_translate_${uid13(12)}`;
+  const node = new CambAiTranslateNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "CAMB_AI_TRANSLATE",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    cambAiTranslate: {
+      apiKey: settings.apiKey,
+      sourceLanguageCode: settings.sourceLanguageCode,
+      targetLanguageCode: settings.targetLanguageCode,
+      model: settings.model,
+      voiceId: settings.voiceId,
+      label: settings.label
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/cea608-encoder.ts
+import { uid as uid14 } from "radash";
+var Cea608EncoderNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createCea608EncoderNode(workflow, settings = {}, nodeId) {
+  const id = nodeId ?? `cea608_${uid14(12)}`;
+  const node = new Cea608EncoderNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "CEA608_ENCODER",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    cea608Encoder: {
+      mode: settings.mode ?? "rollUp",
+      rows: settings.rows ?? 2,
+      autoWrap: settings.autoWrap ?? false
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/ffprobe-monitor.ts
+import { uid as uid15 } from "radash";
+var FfprobeMonitorNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+  /**
+   * Subscribe to a monitor stream on this node.
+   *
+   * - `"stream-info"` — emits a `status` event (key/value map) every time a
+   *   probe cycle completes, containing codec names, resolution, frame rate,
+   *   bit rates, and format.
+   * - `"ffprobe-log"` — emits `log` events with raw ffprobe stderr output.
+   *
+   * Returns an object with an `unsubscribe()` method; call it to stop receiving
+   * events and release the tRPC subscription.
+   */
+  observe(monitorName, onData, onError) {
+    return this.client.trpc.observeNode.subscribe(
+      { workflowId: this.workflowId, nodeId: this.nodeId, monitorName },
+      { onData, ...onError !== void 0 && { onError } }
+    );
+  }
+};
+async function createFfprobeMonitorNode(workflow, settings = {}, nodeId) {
+  const id = nodeId ?? `ffprobe_${uid15(12)}`;
+  const node = new FfprobeMonitorNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "FFPROBE_MONITOR",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    ffprobeMonitor: {
+      intervalMs: settings.intervalMs ?? 3e4,
+      probeSizeBytes: settings.probeSizeBytes ?? 1048576
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/gate.ts
+import { uid as uid16 } from "radash";
+var GateNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createGateNode(workflow, settings = {}, nodeId) {
+  const id = nodeId ?? `gate_${uid16(12)}`;
+  const node = new GateNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "GATE",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    gate: {
+      ...settings.minReady !== void 0 && {
+        minReady: settings.minReady
+      },
+      ...settings.timeoutMs !== void 0 && {
+        timeoutMs: settings.timeoutMs
+      }
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/processor/gemini-translate.ts
+import { uid as uid17 } from "radash";
+var GeminiTranslateNode = class extends BaseNode {
+  settings;
+  constructor(nodeId, workflow, settings) {
+    super(nodeId, workflow.client, workflow.workflowId);
+    this.settings = settings;
+  }
+};
+async function createGeminiTranslateNode(workflow, settings, nodeId) {
+  const id = nodeId ?? `gemini_translate_${uid17(12)}`;
+  const node = new GeminiTranslateNode(id, workflow, settings);
+  node._bindCallbacks(settings);
+  const removeHandler = workflow._onNodeEvent(id, (evt) => {
+    dispatchNodeCallbacks(evt, settings);
+  });
+  node._setEventCleanup(removeHandler);
+  await workflow.client.trpc.createNode.mutate({
+    kind: "GEMINI_TRANSLATE",
+    workflowId: workflow.workflowId,
+    nodeId: id,
+    geminiTranslate: {
+      apiKey: settings.apiKey,
+      targetLanguageCode: settings.targetLanguageCode,
+      label: settings.label
+    }
+  }).catch((err) => {
+    removeHandler();
+    throw err;
+  });
+  return node;
+}
+
+// src/client.ts
+import {
+  createTRPCClient,
+  httpLink,
+  httpSubscriptionLink,
+  splitLink
+} from "@trpc/client";
+import { EventSource } from "eventsource";
+import superjson from "superjson";
+var RemaClient = class _RemaClient {
+  trpc;
+  options;
+  constructor(trpc, options) {
+    this.trpc = trpc;
+    this.options = {
+      host: options.host ?? "127.0.0.1",
+      port: options.port ?? 8080
+    };
+  }
+  static async connect(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? 8080;
+    const url = `http://${host}:${port}/trpc`;
+    const trpc = createTRPCClient({
+      links: [
+        splitLink({
+          condition: (op) => op.type === "subscription",
+          true: httpSubscriptionLink({
+            url,
+            transformer: superjson,
+            EventSource
+          }),
+          false: httpLink({ url, transformer: superjson })
+        })
+      ]
+    });
+    try {
+      await trpc.ping.query();
+      opts.onReady?.();
+    } catch (err) {
+      opts.onFailedToConnect?.();
+      throw new Error(
+        `Failed to connect to rema server at ${host}:${port}: ${String(err)}`
+      );
+    }
+    return new _RemaClient(trpc, opts);
+  }
+  /** No-op kept for API compatibility — SSE has no persistent connection to close. */
+  close() {
+  }
+  /** Fetches the server's health status from the plain HTTP `/api/health` endpoint. */
+  async health() {
+    const url = `http://${this.options.host}:${this.options.port}/api/health`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Health check failed: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+  }
+};
+
+// src/workflow.ts
+var Workflow = class {
+  workflowId;
+  /** Non-private: accessible to factory functions via WorkflowHandle. */
+  client;
+  _callbacks;
+  _eventHandlers = /* @__PURE__ */ new Map();
+  _eventSub = null;
+  _stateSub = null;
+  _seenInList = false;
+  _erroredFired = false;
+  _closedFired = false;
+  /** @internal — use `rema.workflow.create()` instead */
+  constructor(workflowId, client, callbacks = {}) {
+    this.workflowId = workflowId;
+    this.client = client;
+    this._callbacks = callbacks;
+    this._startEventSubscription();
+    this._startStateSubscription();
+  }
+  /**
+   * Register a handler for events emitted by a specific node in this workflow.
+   * Returns an unsubscribe function — call it when the node is closed.
+   * @internal used by node factory functions
+   */
+  _onNodeEvent(nodeId, handler) {
+    let handlers = this._eventHandlers.get(nodeId);
+    if (handlers === void 0) {
+      handlers = /* @__PURE__ */ new Set();
+      this._eventHandlers.set(nodeId, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      this._eventHandlers.get(nodeId)?.delete(handler);
+    };
+  }
+  _startEventSubscription() {
+    this._eventSub = this.client.trpc.workflow.events.subscribe(
+      { workflowId: this.workflowId },
+      {
+        onData: (evt) => {
+          this._eventHandlers.get(evt.nodeId)?.forEach((h) => {
+            h(evt);
+          });
+        },
+        onError: (err) => {
+          console.error(
+            `[rema] workflow ${this.workflowId} events error:`,
+            err
+          );
+        }
+      }
+    );
+  }
+  /**
+   * Watches the server's list of all workflows for this workflow's entry, so
+   * `onError`/`onClose` can be derived without a dedicated per-workflow
+   * subscription: a transition to `status: "crashed"` fires `onError`, and
+   * the entry disappearing (graceful close) fires `onClose`.
+   */
+  _startStateSubscription() {
+    this._stateSub = this.client.trpc.workflow.state.subscribe(void 0, {
+      onData: (workflows) => {
+        const entry = workflows.find((w) => w.id === this.workflowId);
+        if (entry !== void 0) {
+          this._seenInList = true;
+          if (entry.status === "crashed" && !this._erroredFired) {
+            this._erroredFired = true;
+            this._callbacks.onError?.(new Error("workflow worker crashed"));
+          }
+          return;
+        }
+        if (this._seenInList) this._fireClose();
+      },
+      onError: (err) => {
+        console.error(`[rema] workflow ${this.workflowId} state error:`, err);
+      }
+    });
+  }
+  _fireClose() {
+    if (this._closedFired) return;
+    this._closedFired = true;
+    this._stateSub?.unsubscribe();
+    this._callbacks.onClose?.();
+  }
+  // ─── Input nodes ─────────────────────────────────────────────────────────
+  input = {
+    file: (settings, nodeId) => createFileInputNode(this, settings, nodeId),
+    rtmpReader: (settings, nodeId) => createRtmpReaderNode(this, settings, nodeId),
+    /** Announces RTMP publisher connections on an `app` without creating nodes. */
+    rtmpAnnouncer: (settings, nodeId) => createRtmpAnnouncerNode(this, settings, nodeId),
+    /** Announces SRT publisher connections on an `app` without creating nodes. */
+    srtAnnouncer: (settings, nodeId) => createSrtAnnouncerNode(this, settings, nodeId),
+    /** Reads an SRT stream ingested by MediaMTX, pulling it back via RTSP internally. */
+    srtReader: (settings, nodeId) => createSrtReaderNode(this, settings, nodeId),
+    /**
+     * An RTMP multiplexer: accepts any number of simultaneous publishers under
+     * the given `app`. For each connection `onStream` is called with a fresh
+     * `RtmpStreamNode` that can be wired into its own encoder/output pipeline.
+     */
+    rtmpMultiplexer: (settings, nodeId) => createRtmpMultiplexerNode(this, settings, nodeId),
+    /** Format-agnostic caption schedule node. Send captions to it; wire it to a cea608() encoder. */
+    captions: (settings = {}, nodeId) => createCaptionSourceNode(this, settings, nodeId),
+    /**
+     * Audio stream input node.  Push a Node.js `Readable` (or any
+     * `AsyncIterable<Buffer>`) directly into the pipeline by calling
+     * `.stream(source)` on the returned node.
+     */
+    streamInput: (settings, nodeId) => createNodeStreamInputNode(this, settings, nodeId)
+  };
+  // ─── Output nodes ─────────────────────────────────────────────────────────
+  output = {
+    rtmp: (settings, nodeId) => createRtmpOutputNode(this, settings, nodeId),
+    file: (settings, nodeId) => createFileOutputNode(this, settings, nodeId),
+    /** HLS output node. Subscribe it to one or more media/subtitle sources. */
+    hls: (settings, nodeId) => createHlsOutputNode(this, settings, nodeId),
+    /** SRT output node. Pushes MPEG-TS over SRT to the given URL. */
+    srt: (settings, nodeId) => createSrtOutputNode(this, settings, nodeId)
+  };
+  // ─── Processor nodes ──────────────────────────────────────────────────────
+  processor = {
+    /** CEA-608/708 encoder node. Subscribe it to video + a captions() node. */
+    cea608: (settings = {}, nodeId) => createCea608EncoderNode(this, settings, nodeId),
+    /**
+     * ffprobe monitor node.
+     * Subscribe it to any media source; it periodically probes the live stream
+     * and exposes codec/resolution/bitrate info via the `stream-info` monitor.
+     */
+    ffprobeMonitor: (settings = {}, nodeId) => createFfprobeMonitorNode(this, settings, nodeId),
+    /**
+     * Gemini Live Translate node.
+     * Subscribe it to an audio/media source; it outputs translated audio-only
+     * MPEG-TS using the Gemini Live Translate API.
+     */
+    geminiTranslate: (settings, nodeId) => createGeminiTranslateNode(this, settings, nodeId),
+    /**
+     * Camb.ai realtime speech-to-speech translation node.
+     * Subscribe it to an audio/media source; it outputs translated audio-only
+     * MPEG-TS using the Camb.ai realtime translation API.
+     */
+    cambAiTranslate: (settings, nodeId) => createCambAiTranslateNode(this, settings, nodeId),
+    /**
+     * Time-shift node. Subscribe it to exactly one source; it re-emits that
+     * source delayed by `bufferMs`, shared across every downstream
+     * subscriber.
+     */
+    buffer: (settings, nodeId) => createBufferNode(this, settings, nodeId),
+    /**
+     * Synchronization barrier for fan-in from multiple, independently-timed
+     * sources. Subscribe it to two or more sources; it withholds all of them
+     * until enough (`minReady`, default: all) have produced their first
+     * item, then forwards everything live.
+     */
+    gate: (settings = {}, nodeId) => createGateNode(this, settings, nodeId)
+  };
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Close this workflow and deactivate all its nodes on the server.
+   * After calling this the workflow handle is no longer usable.
+   */
+  async close() {
+    this._eventSub?.unsubscribe();
+    this._stateSub?.unsubscribe();
+    await this.client.trpc.workflow.close.mutate({
+      workflowId: this.workflowId
+    });
+    if (!this._closedFired) {
+      this._closedFired = true;
+      this._callbacks.onClose?.();
+    }
+  }
+};
+
+// src/rema.ts
+var Rema = class _Rema {
+  client;
+  _autoCloseWorkflows = /* @__PURE__ */ new Set();
+  constructor(client) {
+    this.client = client;
+  }
+  static async connect(opts = {}) {
+    const client = await RemaClient.connect(opts);
+    return new _Rema(client);
+  }
+  // ─── Workflow management ──────────────────────────────────────────────────
+  workflow = {
+    /**
+     * Create a new isolated workflow on the server.
+     *
+     * All nodes created through the returned `Workflow` handle are scoped to
+     * this workflow; they cannot subscribe to nodes in other workflows.
+     *
+     * @param opts.name               Human-readable label shown in the web UI.
+     * @param opts.workflowId         Optional stable ID. Server generates one if omitted.
+     * @param opts.closeOnDisconnect  When true, this workflow is closed automatically
+     *                                when `rema.close()`/`wf.close()` is called, or
+     *                                when the connection to the server is lost (e.g.
+     *                                the process crashes) for more than a few seconds.
+     * @param opts.parentId           ID of an existing workflow to attach this one to as
+     *                                a child (shown nested in the web UI).
+     * @param opts.closeWithParent    When true, this workflow is closed automatically
+     *                                when its parent workflow is closed.
+     * @param opts.onError            Called if this workflow's worker process crashes.
+     * @param opts.onClose            Called when the workflow closes, whether via
+     *                                `.close()` or a crash.
+     */
+    create: async (opts = {}) => {
+      const info = await this.client.trpc.workflow.create.mutate({
+        workflowId: opts.workflowId,
+        name: opts.name,
+        parentId: opts.parentId,
+        closeWithParent: opts.closeWithParent,
+        closeOnDisconnect: opts.closeOnDisconnect
+      });
+      const wf = new Workflow(info.id, this.client, {
+        ...opts.onError !== void 0 && { onError: opts.onError },
+        ...opts.onClose !== void 0 && { onClose: opts.onClose }
+      });
+      if (opts.closeOnDisconnect === true) {
+        this._autoCloseWorkflows.add(wf);
+      }
+      return wf;
+    },
+    /** List all active workflows on the server. */
+    list: () => this.client.trpc.workflow.list.query()
+  };
+  /** Fetches the server's current health status (uptime, workflow counts, MediaMTX reachability). */
+  health() {
+    return this.client.health();
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Close all `closeOnDisconnect` workflows, then disconnect from the server.
+   */
+  async close() {
+    await Promise.allSettled(
+      [...this._autoCloseWorkflows].map((wf) => wf.close())
+    );
+    this.client.close();
+  }
+};
+
+// src/selectors.ts
+var selectVideo = "VIDEO";
+var selectAudio = "AUDIO";
+var selectCaptions = "CAPTIONS";
+var selectAll = "ALL";
+export {
+  BaseNode,
+  BufferNode,
+  CambAiTranslateNode,
+  CaptionSourceNode,
+  Cea608EncoderNode,
+  FfprobeMonitorNode,
+  FileInputNode,
+  FileOutputNode,
+  GateNode,
+  GeminiTranslateNode,
+  HlsOutputNode,
+  NodeStreamInputNode,
+  Rema,
+  RtmpAnnouncerNode,
+  RtmpMultiplexerNode,
+  RtmpOutputNode,
+  RtmpReaderNode,
+  RtmpStreamNode,
+  SrtAnnouncerNode,
+  SrtOutputNode,
+  SrtReaderNode,
+  Workflow,
+  createNodeStreamInputNode,
+  selectAll,
+  selectAudio,
+  selectCaptions,
+  selectVideo
+};
+//# sourceMappingURL=index.js.map