@shogo-ai/core 1.9.13 → 2.4.1

package/dist/stream-buffer.cjs

@@ -21,15 +21,135 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var stream_buffer_exports = {};
 __export(stream_buffer_exports, {
   StreamBufferStore: () => StreamBufferStore,
-  createBufferingTransform: () => createBufferingTransform
+  TURN_COMPLETE_EVENT_TYPE: () => TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE: () => TURN_SEQ_EVENT_TYPE,
+  compactSseFrames: () => compactSseFrames,
+  createBufferingTransform: () => createBufferingTransform,
+  encodeTurnCompleteFrame: () => encodeTurnCompleteFrame,
+  encodeTurnSeqFrame: () => encodeTurnSeqFrame
 });
 module.exports = __toCommonJS(stream_buffer_exports);
+
+// src/stream-compaction.ts
+var TURN_SEQ_EVENT_TYPE = "data-turn-seq";
+var DELTA_PART = {
+  "text-delta": "text",
+  "reasoning-delta": "reasoning"
+};
+var PART_BOUNDARY = {
+  "text-end": "text",
+  "reasoning-end": "reasoning",
+  "text-start": "text",
+  "reasoning-start": "reasoning"
+};
+function compactSseFrames(frames) {
+  if (frames.length === 0) return new Uint8Array(0);
+  const decoder = new TextDecoder();
+  let text = "";
+  for (const frame of frames) text += decoder.decode(frame, { stream: true });
+  text += decoder.decode();
+  const events = text.split("\n\n");
+  const tail = events.pop() ?? "";
+  const out = [];
+  const openParts = /* @__PURE__ */ new Map();
+  const openToolInputs = /* @__PURE__ */ new Map();
+  const preliminaryOutputs = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const chunk = parseEvent(event);
+    if (!chunk) {
+      out.push({ raw: event });
+      continue;
+    }
+    const type = chunk.type;
+    if (type === TURN_SEQ_EVENT_TYPE) continue;
+    if (type in PART_BOUNDARY) {
+      openParts.delete(`${PART_BOUNDARY[type]}:${chunk.id}`);
+      out.push({ chunk });
+      continue;
+    }
+    if (type in DELTA_PART && typeof chunk.delta === "string") {
+      const key = `${DELTA_PART[type]}:${chunk.id}`;
+      const merged = openParts.get(key);
+      if (merged) {
+        merged.delta += chunk.delta;
+        if (chunk.providerMetadata !== void 0) merged.providerMetadata = chunk.providerMetadata;
+        continue;
+      }
+      const copy = { ...chunk };
+      openParts.set(key, copy);
+      out.push({ chunk: copy });
+      continue;
+    }
+    if (type === "tool-input-delta" && typeof chunk.inputTextDelta === "string") {
+      const index = openToolInputs.get(chunk.toolCallId);
+      const existing = index !== void 0 ? out[index] : null;
+      if (existing && "chunk" in existing) {
+        existing.chunk.inputTextDelta += chunk.inputTextDelta;
+        continue;
+      }
+      openToolInputs.set(chunk.toolCallId, out.length);
+      out.push({ chunk: { ...chunk } });
+      continue;
+    }
+    if (type === "tool-input-available" || type === "tool-input-error") {
+      const index = openToolInputs.get(chunk.toolCallId);
+      if (index !== void 0) out[index] = null;
+      openToolInputs.delete(chunk.toolCallId);
+    } else if (type === "tool-input-start") {
+      openToolInputs.delete(chunk.toolCallId);
+    } else if (type === "tool-output-available" || type === "tool-output-error") {
+      const superseded = preliminaryOutputs.get(chunk.toolCallId);
+      if (superseded !== void 0) {
+        out[superseded] = null;
+        preliminaryOutputs.delete(chunk.toolCallId);
+      }
+      if (type === "tool-output-available" && chunk.preliminary === true) {
+        preliminaryOutputs.set(chunk.toolCallId, out.length);
+      }
+    }
+    out.push({ chunk });
+  }
+  let result = "";
+  for (const entry of out) {
+    if (!entry) continue;
+    result += "chunk" in entry ? encodeEvent(entry.chunk) : `${entry.raw}
+
+`;
+  }
+  result += tail;
+  return new TextEncoder().encode(result);
+}
+function encodeTurnSeqFrame(turnId, seq) {
+  return new TextEncoder().encode(
+    encodeEvent({ type: TURN_SEQ_EVENT_TYPE, data: { turnId, seq }, transient: true })
+  );
+}
+function encodeEvent(chunk) {
+  return `data: ${JSON.stringify(chunk)}
+
+`;
+}
+function parseEvent(event) {
+  if (!event.startsWith("data: ") || event.includes("\n")) return null;
+  const payload = event.slice(6);
+  if (!payload.startsWith("{")) return null;
+  try {
+    const chunk = JSON.parse(payload);
+    return chunk && typeof chunk.type === "string" ? chunk : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/stream-buffer.ts
 var CLEANUP_INTERVAL_MS = 6e4;
 var MAX_BUFFER_AGE_MS = 30 * 6e4;
 var COMPLETED_GRACE_MS = 3e4;
+var TURN_REPLY_TTL_MS = 60 * 6e4;
 var StreamBufferStore = class {
   constructor() {
     this.buffers = /* @__PURE__ */ new Map();
+    this.replies = /* @__PURE__ */ new Map();
     this.cleanupTimer = null;
     this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
     const handle = this.cleanupTimer;
@@ -143,6 +263,44 @@ var StreamBufferStore = class {
       lastEventAt: buf.lastEventAt
     };
   }
+  /**
+   * Keep the reply a turn finished with, so it can still be read after the
+   * buffer is evicted (30 s grace) — e.g. by the API's call follower, or by a
+   * reconciliation pass long after the stream is gone. Keyed by the same
+   * session key as the buffer.
+   */
+  recordTurnReply(key, reply) {
+    const trimmed = reply?.trim();
+    if (!trimmed) return;
+    const now = Date.now();
+    this.pruneReplies(now);
+    this.replies.set(key, {
+      turnId: this.buffers.get(key)?.turnId ?? "",
+      reply,
+      completedAt: now
+    });
+  }
+  /**
+   * The terminal reply for a session, or null when none was recorded or it
+   * expired. A reply belonging to an older turn of a session that has since
+   * started a new one is never returned.
+   */
+  turnReply(key) {
+    const entry = this.replies.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.completedAt > TURN_REPLY_TTL_MS) {
+      this.replies.delete(key);
+      return null;
+    }
+    const current = this.buffers.get(key);
+    if (current && entry.turnId && current.turnId !== entry.turnId) return null;
+    return entry;
+  }
+  pruneReplies(now) {
+    for (const [key, entry] of this.replies) {
+      if (now - entry.completedAt > TURN_REPLY_TTL_MS) this.replies.delete(key);
+    }
+  }
   /**
    * Create a ReadableStream that first replays all buffered chunks past
    * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
@@ -155,15 +313,29 @@ var StreamBufferStore = class {
     if (!buf) return null;
     const fromSeq = Math.max(0, opts.fromSeq ?? 0);
     let subscribedController = null;
+    if (opts.buildReplay) return this.createBuiltReplayStream(buf, fromSeq, opts.buildReplay);
     return new ReadableStream({
       start(controller) {
-        for (const frame of buf.frames) {
-          if (frame.seq <= fromSeq) continue;
+        if (opts.compact) {
+          const pending = buf.frames.filter((frame) => frame.seq > fromSeq);
+          const compacted = compactSseFrames(pending.map((frame) => frame.chunk));
           try {
-            controller.enqueue(frame.chunk);
+            if (compacted.byteLength > 0) controller.enqueue(compacted);
+            if (pending.length > 0 && buf.status === "active") {
+              controller.enqueue(encodeTurnSeqFrame(buf.turnId, buf.nextSeq - 1));
+            }
           } catch {
             return;
           }
+        } else {
+          for (const frame of buf.frames) {
+            if (frame.seq <= fromSeq) continue;
+            try {
+              controller.enqueue(frame.chunk);
+            } catch {
+              return;
+            }
+          }
         }
         if (buf.status !== "active") {
           try {
@@ -183,8 +355,59 @@ var StreamBufferStore = class {
       }
     });
   }
+  createBuiltReplayStream(buf, fromSeq, buildReplay) {
+    const pending = buf.frames.filter((frame) => frame.seq > fromSeq).map((frame) => frame.chunk);
+    const ctx = { turnId: buf.turnId, lastSeq: buf.nextSeq - 1 };
+    const held = [];
+    let ended = false;
+    let target = null;
+    const proxy = {
+      enqueue(chunk) {
+        if (target) target.enqueue(chunk);
+        else held.push(chunk);
+      },
+      close() {
+        if (target) target.close();
+        else ended = true;
+      },
+      error(reason) {
+        if (target) target.error(reason);
+        else ended = true;
+      }
+    };
+    const active = buf.status === "active";
+    if (active) buf.subscribers.add(proxy);
+    return new ReadableStream({
+      async start(controller) {
+        let replay;
+        try {
+          replay = await buildReplay(pending, ctx);
+        } catch {
+          replay = compactSseFrames(pending);
+        }
+        try {
+          if (replay.byteLength > 0) controller.enqueue(replay);
+          if (pending.length > 0 && active) controller.enqueue(encodeTurnSeqFrame(ctx.turnId, ctx.lastSeq));
+          for (const chunk of held) controller.enqueue(chunk);
+          held.length = 0;
+          if (!active || ended || buf.status !== "active") {
+            controller.close();
+            return;
+          }
+          target = controller;
+        } catch {
+          buf.subscribers.delete(proxy);
+        }
+      },
+      cancel() {
+        buf.subscribers.delete(proxy);
+        target = null;
+      }
+    });
+  }
   cleanup() {
     const now = Date.now();
+    this.pruneReplies(now);
     for (const [key, buf] of this.buffers) {
       if (buf.status !== "active" && buf.completedAt && now - buf.completedAt > COMPLETED_GRACE_MS) {
         this.buffers.delete(key);
@@ -203,6 +426,7 @@ var StreamBufferStore = class {
       this.completeBuffer(buf, "disposed");
     }
     this.buffers.clear();
+    this.replies.clear();
   }
   completeBuffer(buf, reason) {
     if (buf.status !== "active") return;
@@ -233,6 +457,14 @@ var StreamBufferStore = class {
     buf.subscribers.clear();
   }
 };
+var TURN_COMPLETE_EVENT_TYPE = "data-turn-complete";
+function encodeTurnCompleteFrame(data) {
+  return new TextEncoder().encode(
+    `data: ${JSON.stringify({ type: TURN_COMPLETE_EVENT_TYPE, data })}
+
+`
+  );
+}
 function generateTurnId() {
   try {
     if (typeof globalThis.crypto?.randomUUID === "function") {
@@ -256,6 +488,11 @@ function createBufferingTransform(store, key) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StreamBufferStore,
-  createBufferingTransform
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
+  createBufferingTransform,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame
 });
 //# sourceMappingURL=stream-buffer.cjs.map

package/dist/stream-buffer.d.cts

@@ -1,3 +1,30 @@
+/**
+ * Compaction of a buffered AI SDK UI-message stream for replay.
+ *
+ * A long turn buffers tens of thousands of tiny frames (one per text, reasoning
+ * or tool-input delta). Replaying them one by one makes a reconnecting client
+ * rebuild the message chunk by chunk, which takes seconds on a phone. The
+ * compacted replay produces the same message with a handful of chunks:
+ *
+ *   - all deltas of one text / reasoning part are merged into its first delta
+ *     (a part runs from its `*-start` to its `*-end`; providers reuse ids
+ *     across steps, so merging never crosses a start);
+ *   - tool-input deltas are merged per tool call, and dropped entirely once
+ *     `tool-input-available` / `tool-input-error` carries the full input;
+ *   - of a tool call's `preliminary: true` outputs only the latest is kept (each
+ *     one carries the whole accumulated state, so it replaces the earlier ones),
+ *     and all of them are dropped once the call's final output or error is in
+ *     the buffer — a sub-agent streams one of these per update;
+ *   - `data-turn-seq` heartbeats are dropped; the caller appends one with the
+ *     exact current seq so `?fromSeq=N` reconnects stay correct.
+ *
+ * Anything that isn't a parseable `data: {json}` event is kept verbatim, in
+ * place, as is a trailing partial event.
+ */
+declare const TURN_SEQ_EVENT_TYPE: "data-turn-seq";
+declare function compactSseFrames(frames: Uint8Array[]): Uint8Array;
+declare function encodeTurnSeqFrame(turnId: string, seq: number): Uint8Array;
+
 /**
  * In-memory stream buffer + turn ledger for SSE reconnect support.
  *
@@ -16,6 +43,7 @@
  *
  * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
  */
+
 type TurnStatus = 'active' | 'completed' | 'aborted' | 'failed';
 interface TurnTerminal {
     reason?: string;
@@ -41,6 +69,27 @@ interface ReplayOptions {
      * Skip frames with seq <= fromSeq. Use 0 (or omit) to replay from the start.
      */
     fromSeq?: number;
+    /**
+     * Replay the buffered frames as one compacted chunk (see
+     * `compactSseFrames`) followed by a `data-turn-seq` frame with the exact
+     * last seq, then the live frames. The rebuilt message is the same; the
+     * client processes a handful of chunks instead of one per delta.
+     */
+    compact?: boolean;
+    /**
+     * Replace the buffered-frame replay with caller-built bytes. Receives the
+     * frames after `fromSeq` and returns what to send before the live frames
+     * (a `data-turn-seq` frame with the exact last seq is appended). Takes
+     * precedence over `compact`; if it throws, the replay falls back to
+     * `compactSseFrames`.
+     *
+     * The builder may be async: live frames written while it runs are held
+     * back and delivered after its output, in order.
+     */
+    buildReplay?: (frames: Uint8Array[], ctx: {
+        turnId: string;
+        lastSeq: number;
+    }) => Uint8Array | Promise<Uint8Array>;
 }
 interface TurnSnapshot {
     turnId: string;
@@ -51,8 +100,15 @@ interface TurnSnapshot {
     completedAt: number | null;
     lastEventAt: number;
 }
+/** The reply a pipeline turn finished with, kept past its buffer's lifetime. */
+interface TurnReply {
+    turnId: string;
+    reply: string;
+    completedAt: number;
+}
 declare class StreamBufferStore {
     private buffers;
+    private replies;
     private cleanupTimer;
     constructor();
     /**
@@ -78,6 +134,20 @@ declare class StreamBufferStore {
     has(key: string): boolean;
     /** Read-only metadata about a buffered turn. Useful for resume responses. */
     snapshot(key: string): TurnSnapshot | null;
+    /**
+     * Keep the reply a turn finished with, so it can still be read after the
+     * buffer is evicted (30 s grace) — e.g. by the API's call follower, or by a
+     * reconciliation pass long after the stream is gone. Keyed by the same
+     * session key as the buffer.
+     */
+    recordTurnReply(key: string, reply: string): void;
+    /**
+     * The terminal reply for a session, or null when none was recorded or it
+     * expired. A reply belonging to an older turn of a session that has since
+     * started a new one is never returned.
+     */
+    turnReply(key: string): TurnReply | null;
+    private pruneReplies;
     /**
      * Create a ReadableStream that first replays all buffered chunks past
      * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
@@ -86,11 +156,37 @@ declare class StreamBufferStore {
      * Returns null if no buffer exists for the key.
      */
     createReplayStream(key: string, opts?: ReplayOptions): ReadableStream<Uint8Array> | null;
+    private createBuiltReplayStream;
     cleanup(): void;
     dispose(): void;
     private completeBuffer;
     private failBuffer;
 }
+/**
+ * The SSE data-part event type the client's auto-resuming fetch treats as a
+ * turn's terminal marker. The client keeps reconnecting to `/stream?fromSeq=N`
+ * until it parses one of these; a buffer that reaches a terminal `status`
+ * WITHOUT such a frame makes the client replay the tail forever and pins
+ * `useChat().status` at `streaming` (composer stuck on Stop/Queue).
+ */
+declare const TURN_COMPLETE_EVENT_TYPE: "data-turn-complete";
+interface TurnCompleteFrameData {
+    turnId: string;
+    chatSessionId: string;
+    status: TurnStatus;
+    error?: string;
+    lastSeq: number;
+    completedAt?: number;
+}
+/**
+ * Encode a `data-turn-complete` SSE frame as raw bytes suitable for
+ * {@link StreamBufferWriter.append}. Matches the AI SDK UI-message-stream wire
+ * format (`data: <json>\n\n`) so the client's SSE parser recognizes it
+ * identically to frames written through the live `writer`. Use this to
+ * synthesize a terminal marker when a turn ends abnormally (transport error,
+ * abort race) before the normal terminal frame was emitted.
+ */
+declare function encodeTurnCompleteFrame(data: TurnCompleteFrameData): Uint8Array;
 /**
  * TransformStream that copies every chunk into a StreamBufferStore while
  * passing it through unchanged. On flush/cancel, completes the buffer.
@@ -100,4 +196,4 @@ declare class StreamBufferStore {
  */
 declare function createBufferingTransform(store: StreamBufferStore, key: string): TransformStream<Uint8Array, Uint8Array>;
 
-export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, type TurnSnapshot, type TurnStatus, type TurnTerminal, createBufferingTransform };
+export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, TURN_COMPLETE_EVENT_TYPE, TURN_SEQ_EVENT_TYPE, type TurnCompleteFrameData, type TurnReply, type TurnSnapshot, type TurnStatus, type TurnTerminal, compactSseFrames, createBufferingTransform, encodeTurnCompleteFrame, encodeTurnSeqFrame };

package/dist/stream-buffer.d.ts

@@ -1,3 +1,30 @@
+/**
+ * Compaction of a buffered AI SDK UI-message stream for replay.
+ *
+ * A long turn buffers tens of thousands of tiny frames (one per text, reasoning
+ * or tool-input delta). Replaying them one by one makes a reconnecting client
+ * rebuild the message chunk by chunk, which takes seconds on a phone. The
+ * compacted replay produces the same message with a handful of chunks:
+ *
+ *   - all deltas of one text / reasoning part are merged into its first delta
+ *     (a part runs from its `*-start` to its `*-end`; providers reuse ids
+ *     across steps, so merging never crosses a start);
+ *   - tool-input deltas are merged per tool call, and dropped entirely once
+ *     `tool-input-available` / `tool-input-error` carries the full input;
+ *   - of a tool call's `preliminary: true` outputs only the latest is kept (each
+ *     one carries the whole accumulated state, so it replaces the earlier ones),
+ *     and all of them are dropped once the call's final output or error is in
+ *     the buffer — a sub-agent streams one of these per update;
+ *   - `data-turn-seq` heartbeats are dropped; the caller appends one with the
+ *     exact current seq so `?fromSeq=N` reconnects stay correct.
+ *
+ * Anything that isn't a parseable `data: {json}` event is kept verbatim, in
+ * place, as is a trailing partial event.
+ */
+declare const TURN_SEQ_EVENT_TYPE: "data-turn-seq";
+declare function compactSseFrames(frames: Uint8Array[]): Uint8Array;
+declare function encodeTurnSeqFrame(turnId: string, seq: number): Uint8Array;
+
 /**
  * In-memory stream buffer + turn ledger for SSE reconnect support.
  *
@@ -16,6 +43,7 @@
  *
  * Lifted into the SDK from `@shogo/shared-runtime` (was AGPL) under MIT.
  */
+
 type TurnStatus = 'active' | 'completed' | 'aborted' | 'failed';
 interface TurnTerminal {
     reason?: string;
@@ -41,6 +69,27 @@ interface ReplayOptions {
      * Skip frames with seq <= fromSeq. Use 0 (or omit) to replay from the start.
      */
     fromSeq?: number;
+    /**
+     * Replay the buffered frames as one compacted chunk (see
+     * `compactSseFrames`) followed by a `data-turn-seq` frame with the exact
+     * last seq, then the live frames. The rebuilt message is the same; the
+     * client processes a handful of chunks instead of one per delta.
+     */
+    compact?: boolean;
+    /**
+     * Replace the buffered-frame replay with caller-built bytes. Receives the
+     * frames after `fromSeq` and returns what to send before the live frames
+     * (a `data-turn-seq` frame with the exact last seq is appended). Takes
+     * precedence over `compact`; if it throws, the replay falls back to
+     * `compactSseFrames`.
+     *
+     * The builder may be async: live frames written while it runs are held
+     * back and delivered after its output, in order.
+     */
+    buildReplay?: (frames: Uint8Array[], ctx: {
+        turnId: string;
+        lastSeq: number;
+    }) => Uint8Array | Promise<Uint8Array>;
 }
 interface TurnSnapshot {
     turnId: string;
@@ -51,8 +100,15 @@ interface TurnSnapshot {
     completedAt: number | null;
     lastEventAt: number;
 }
+/** The reply a pipeline turn finished with, kept past its buffer's lifetime. */
+interface TurnReply {
+    turnId: string;
+    reply: string;
+    completedAt: number;
+}
 declare class StreamBufferStore {
     private buffers;
+    private replies;
     private cleanupTimer;
     constructor();
     /**
@@ -78,6 +134,20 @@ declare class StreamBufferStore {
     has(key: string): boolean;
     /** Read-only metadata about a buffered turn. Useful for resume responses. */
     snapshot(key: string): TurnSnapshot | null;
+    /**
+     * Keep the reply a turn finished with, so it can still be read after the
+     * buffer is evicted (30 s grace) — e.g. by the API's call follower, or by a
+     * reconciliation pass long after the stream is gone. Keyed by the same
+     * session key as the buffer.
+     */
+    recordTurnReply(key: string, reply: string): void;
+    /**
+     * The terminal reply for a session, or null when none was recorded or it
+     * expired. A reply belonging to an older turn of a session that has since
+     * started a new one is never returned.
+     */
+    turnReply(key: string): TurnReply | null;
+    private pruneReplies;
     /**
      * Create a ReadableStream that first replays all buffered chunks past
      * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
@@ -86,11 +156,37 @@ declare class StreamBufferStore {
      * Returns null if no buffer exists for the key.
      */
     createReplayStream(key: string, opts?: ReplayOptions): ReadableStream<Uint8Array> | null;
+    private createBuiltReplayStream;
     cleanup(): void;
     dispose(): void;
     private completeBuffer;
     private failBuffer;
 }
+/**
+ * The SSE data-part event type the client's auto-resuming fetch treats as a
+ * turn's terminal marker. The client keeps reconnecting to `/stream?fromSeq=N`
+ * until it parses one of these; a buffer that reaches a terminal `status`
+ * WITHOUT such a frame makes the client replay the tail forever and pins
+ * `useChat().status` at `streaming` (composer stuck on Stop/Queue).
+ */
+declare const TURN_COMPLETE_EVENT_TYPE: "data-turn-complete";
+interface TurnCompleteFrameData {
+    turnId: string;
+    chatSessionId: string;
+    status: TurnStatus;
+    error?: string;
+    lastSeq: number;
+    completedAt?: number;
+}
+/**
+ * Encode a `data-turn-complete` SSE frame as raw bytes suitable for
+ * {@link StreamBufferWriter.append}. Matches the AI SDK UI-message-stream wire
+ * format (`data: <json>\n\n`) so the client's SSE parser recognizes it
+ * identically to frames written through the live `writer`. Use this to
+ * synthesize a terminal marker when a turn ends abnormally (transport error,
+ * abort race) before the normal terminal frame was emitted.
+ */
+declare function encodeTurnCompleteFrame(data: TurnCompleteFrameData): Uint8Array;
 /**
  * TransformStream that copies every chunk into a StreamBufferStore while
  * passing it through unchanged. On flush/cancel, completes the buffer.
@@ -100,4 +196,4 @@ declare class StreamBufferStore {
  */
 declare function createBufferingTransform(store: StreamBufferStore, key: string): TransformStream<Uint8Array, Uint8Array>;
 
-export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, type TurnSnapshot, type TurnStatus, type TurnTerminal, createBufferingTransform };
+export { type ReplayOptions, StreamBufferStore, type StreamBufferWriter, TURN_COMPLETE_EVENT_TYPE, TURN_SEQ_EVENT_TYPE, type TurnCompleteFrameData, type TurnReply, type TurnSnapshot, type TurnStatus, type TurnTerminal, compactSseFrames, createBufferingTransform, encodeTurnCompleteFrame, encodeTurnSeqFrame };

package/dist/stream-buffer.js

@@ -1,9 +1,19 @@
 import {
   StreamBufferStore,
-  createBufferingTransform
-} from "./chunk-ELMG6OXT.js";
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
+  createBufferingTransform,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame
+} from "./chunk-H625AGFN.js";
 export {
   StreamBufferStore,
-  createBufferingTransform
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
+  createBufferingTransform,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame
 };
 //# sourceMappingURL=stream-buffer.js.map

package/dist/tech-stack-registry.cjs

@@ -21,7 +21,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var tech_stack_registry_exports = {};
 __export(tech_stack_registry_exports, {
   TECH_STACK_REGISTRY: () => TECH_STACK_REGISTRY,
+  getDeclaredPorts: () => getDeclaredPorts,
+  getMinimumInstanceSize: () => getMinimumInstanceSize,
   getStackEntry: () => getStackEntry,
+  isDockerTechStack: () => isDockerTechStack,
   isMobileTechStack: () => isMobileTechStack,
   stackSeedsItself: () => stackSeedsItself,
   usesMetroBundler: () => usesMetroBundler
@@ -32,14 +35,35 @@ var TECH_STACK_REGISTRY = {
   "react-app": { id: "react-app", target: "web" },
   "threejs-game": { id: "threejs-game", target: "web" },
   "phaser-game": { id: "phaser-game", target: "web" },
+  // Video (Remotion). `target: 'web'` because the canvas preview is the
+  // Remotion Player page the runtime serves from `dist/`; the stack's own
+  // `stack.json` declares `runtime.devServer: 'static-build'`, so no new
+  // target value (and therefore no new sizing/publish rules) is needed.
+  "video-editor": { id: "video-editor", target: "web", seedsOwnTemplate: true },
   // Mobile (Metro/Expo) — agent-runtime owns the seed.
   "expo-app": { id: "expo-app", target: "mobile", metro: true, seedsOwnTemplate: true },
   "expo-three": { id: "expo-three", target: "mobile", metro: true, seedsOwnTemplate: true },
   "react-native": { id: "react-native", target: "mobile", metro: true, seedsOwnTemplate: true },
   // Data / scripting
   "python-data": { id: "python-data", target: "data", seedsOwnTemplate: true },
+  // Multi-service backend (dockerd + docker compose). Requires the
+  // Docker-capable metal VM class; gated separately by
+  // `runtime.docker_class_enabled` (see apps/api/src/lib/runtime-class-setting.ts).
+  "docker-compose": {
+    id: "docker-compose",
+    target: "data",
+    seedsOwnTemplate: true,
+    vmClass: "docker",
+    minimumInstanceSize: "large",
+    ports: [
+      { port: 8e3, label: "app", protocol: "http", defaultVisibility: "preview" },
+      { port: 5432, label: "postgres", protocol: "tcp", defaultVisibility: "tunnel" }
+    ]
+  },
   // Native (full game engines)
   "unity-game": { id: "unity-game", target: "native", seedsOwnTemplate: true },
+  // Bring-your-own framework: the preview runs the project's static build.
+  custom: { id: "custom", target: "web", seedsOwnTemplate: true },
   // Bare / no-stack
   none: { id: "none", target: "none", seedsOwnTemplate: true }
 };
@@ -56,10 +80,22 @@ function usesMetroBundler(techStackId) {
 function stackSeedsItself(techStackId) {
   return getStackEntry(techStackId)?.seedsOwnTemplate === true;
 }
+function isDockerTechStack(techStackId) {
+  return getStackEntry(techStackId)?.vmClass === "docker";
+}
+function getMinimumInstanceSize(techStackId) {
+  return getStackEntry(techStackId)?.minimumInstanceSize ?? null;
+}
+function getDeclaredPorts(techStackId) {
+  return getStackEntry(techStackId)?.ports ?? [];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TECH_STACK_REGISTRY,
+  getDeclaredPorts,
+  getMinimumInstanceSize,
   getStackEntry,
+  isDockerTechStack,
   isMobileTechStack,
   stackSeedsItself,
   usesMetroBundler