@shogo-ai/core 1.10.0 → 2.4.1

package/dist/index.cjs

@@ -20,19 +20,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BINARY_FILE_BASENAMES: () => BINARY_FILE_BASENAMES,
   BINARY_FILE_EXTENSIONS: () => BINARY_FILE_EXTENSIONS,
+  BINARY_FILE_TRANSIENT_SUFFIXES: () => BINARY_FILE_TRANSIENT_SUFFIXES,
   StreamBufferStore: () => StreamBufferStore,
   TECH_STACK_REGISTRY: () => TECH_STACK_REGISTRY,
+  TURN_COMPLETE_EVENT_TYPE: () => TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE: () => TURN_SEQ_EVENT_TYPE,
+  compactSseFrames: () => compactSseFrames,
   createBufferingTransform: () => createBufferingTransform,
   createLogger: () => createLogger,
+  emitLogToSink: () => emitLogToSink,
+  encodeTurnCompleteFrame: () => encodeTurnCompleteFrame,
+  encodeTurnSeqFrame: () => encodeTurnSeqFrame,
   extractUserText: () => extractUserText,
   findLastUserMessage: () => findLastUserMessage,
+  getDeclaredPorts: () => getDeclaredPorts,
+  getMinimumInstanceSize: () => getMinimumInstanceSize,
   getStackEntry: () => getStackEntry,
   initInstrumentation: () => initInstrumentation,
+  isBinaryBuffer: () => isBinaryBuffer,
   isBinaryFilePath: () => isBinaryFilePath,
+  isDockerTechStack: () => isDockerTechStack,
   isMacOSJunkName: () => isMacOSJunkName,
   isMacOSJunkPath: () => isMacOSJunkPath,
   isMobileTechStack: () => isMobileTechStack,
+  setOtelLogSink: () => setOtelLogSink,
+  setTraceContextProvider: () => setTraceContextProvider,
   shutdownInstrumentation: () => shutdownInstrumentation,
   stackSeedsItself: () => stackSeedsItself,
   traceOperation: () => traceOperation,
@@ -60,6 +74,21 @@ function formatEntry(entry) {
   const extraStr = Object.keys(extra).length > 0 ? " " + JSON.stringify(extra) : "";
   return `[${service}] ${msg}${extraStr}`;
 }
+var logSink = null;
+function setOtelLogSink(sink) {
+  logSink = sink;
+}
+function emitLogToSink(entry) {
+  if (!logSink) return;
+  try {
+    logSink({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
+  } catch {
+  }
+}
+var traceContextProvider = null;
+function setTraceContextProvider(provider) {
+  traceContextProvider = provider;
+}
 function createLogger(service, defaultExtra) {
   function log(level, msg, extra) {
     if (!shouldLog(level)) return;
@@ -71,6 +100,16 @@ function createLogger(service, defaultExtra) {
       ...defaultExtra,
       ...extra
     };
+    if (traceContextProvider) {
+      try {
+        const tc = traceContextProvider();
+        if (tc) {
+          entry.trace_id = tc.trace_id;
+          entry.span_id = tc.span_id;
+        }
+      } catch {
+      }
+    }
     const formatted = formatEntry(entry);
     switch (level) {
       case "error":
@@ -83,6 +122,12 @@ function createLogger(service, defaultExtra) {
         console.log(formatted);
         break;
     }
+    if (logSink) {
+      try {
+        logSink(entry);
+      } catch {
+      }
+    }
   }
   return {
     debug: (msg, extra) => log("debug", msg, extra),
@@ -95,13 +140,23 @@ function createLogger(service, defaultExtra) {
 
 // src/instrumentation.ts
 var import_api = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
 var import_sdk_node = require("@opentelemetry/sdk-node");
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
 var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
 var import_resources = require("@opentelemetry/resources");
 var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var SEVERITY_BY_LEVEL = {
+  debug: { number: import_api_logs.SeverityNumber.DEBUG, text: "DEBUG" },
+  info: { number: import_api_logs.SeverityNumber.INFO, text: "INFO" },
+  warn: { number: import_api_logs.SeverityNumber.WARN, text: "WARN" },
+  error: { number: import_api_logs.SeverityNumber.ERROR, text: "ERROR" }
+};
 var sdk = null;
 function initInstrumentation(config) {
+  if (sdk) return;
   const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
   if (!endpoint) {
     console.log(`[OTEL] Tracing disabled for ${config.serviceName} (OTEL_EXPORTER_OTLP_ENDPOINT not set)`);
@@ -115,18 +170,43 @@ function initInstrumentation(config) {
   }
   const serviceName = process.env.OTEL_SERVICE_NAME || config.serviceName;
   console.log(`[OTEL] Configuring ${serviceName} \u2192 ${endpoint}/v1/traces`);
+  const exportTimeoutMs = Number(process.env.OTEL_EXPORTER_TIMEOUT_MS ?? 3e3);
   let traceExporter;
   try {
     traceExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
       url: `${endpoint}/v1/traces`,
-      headers
+      headers,
+      timeoutMillis: exportTimeoutMs
     });
   } catch (err) {
     console.error(`[OTEL] Failed to create exporter: ${err.message}`);
     return;
   }
   const isProduction2 = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "staging";
-  const spanProcessor = isProduction2 ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  const spanProcessor = isProduction2 ? new import_sdk_trace_base.BatchSpanProcessor(traceExporter, {
+    maxQueueSize: 2048,
+    maxExportBatchSize: 512,
+    scheduledDelayMillis: 5e3,
+    exportTimeoutMillis: exportTimeoutMs
+  }) : new import_sdk_trace_base.SimpleSpanProcessor(traceExporter);
+  let logRecordProcessors = [];
+  try {
+    const logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
+      url: `${endpoint}/v1/logs`,
+      headers,
+      timeoutMillis: exportTimeoutMs
+    });
+    logRecordProcessors = [
+      isProduction2 ? new import_sdk_logs.BatchLogRecordProcessor(logExporter, {
+        maxQueueSize: 2048,
+        maxExportBatchSize: 512,
+        scheduledDelayMillis: 5e3,
+        exportTimeoutMillis: exportTimeoutMs
+      }) : new import_sdk_logs.SimpleLogRecordProcessor(logExporter)
+    ];
+  } catch (err) {
+    console.warn(`[OTEL] Failed to create log exporter for ${serviceName}: ${err.message}`);
+  }
   sdk = new import_sdk_node.NodeSDK({
     resource: (0, import_resources.resourceFromAttributes)({
       [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
@@ -134,6 +214,7 @@ function initInstrumentation(config) {
       "deployment.environment.name": process.env.NODE_ENV || "development"
     }),
     spanProcessors: [spanProcessor],
+    logRecordProcessors,
     instrumentations: []
   });
   try {
@@ -144,6 +225,24 @@ function initInstrumentation(config) {
     sdk = null;
     return;
   }
+  setTraceContextProvider(() => {
+    const ctx = import_api.trace.getActiveSpan()?.spanContext();
+    return ctx && (0, import_api.isSpanContextValid)(ctx) ? { trace_id: ctx.traceId, span_id: ctx.spanId } : null;
+  });
+  if (logRecordProcessors.length > 0) {
+    const otelLogger = import_api_logs.logs.getLogger(serviceName);
+    setOtelLogSink((entry) => {
+      const { level, msg, service, timestamp, ...attrs } = entry;
+      const severity = SEVERITY_BY_LEVEL[level] ?? SEVERITY_BY_LEVEL.info;
+      otelLogger.emit({
+        severityNumber: severity.number,
+        severityText: severity.text,
+        body: msg,
+        attributes: { service, ...attrs }
+      });
+    });
+    console.log(`[OTEL] Logs exporter enabled for ${serviceName} \u2192 ${endpoint}/v1/logs`);
+  }
   try {
     const tracer = import_api.trace.getTracer(serviceName);
     const testSpan = tracer.startSpan("otel.startup-test", {
@@ -164,13 +263,24 @@ function initInstrumentation(config) {
   }
 }
 async function shutdownInstrumentation() {
-  if (sdk) {
-    try {
-      await sdk.shutdown();
-      console.log("[OTEL] Tracing shut down");
-    } catch (err) {
-      console.error("[OTEL] Error shutting down:", err.message);
-    }
+  if (!sdk) return;
+  setOtelLogSink(null);
+  setTraceContextProvider(null);
+  const shutdownTimeoutMs = Number(process.env.OTEL_SHUTDOWN_TIMEOUT_MS ?? 2e3);
+  let timer;
+  try {
+    await Promise.race([
+      sdk.shutdown(),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, shutdownTimeoutMs);
+      })
+    ]);
+    console.log("[OTEL] Tracing shut down");
+  } catch (err) {
+    console.error("[OTEL] Error shutting down:", err.message);
+  } finally {
+    if (timer) clearTimeout(timer);
+    sdk = null;
   }
 }
 function traceOperation(tracerName, spanName, attributes, fn) {
@@ -190,13 +300,126 @@ function traceOperation(tracerName, spanName, attributes, fn) {
   });
 }
 
+// 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;
@@ -310,6 +533,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
@@ -322,15 +583,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 {
@@ -350,8 +625,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);
@@ -370,6 +696,7 @@ var StreamBufferStore = class {
       this.completeBuffer(buf, "disposed");
     }
     this.buffers.clear();
+    this.replies.clear();
   }
   completeBuffer(buf, reason) {
     if (buf.status !== "active") return;
@@ -400,6 +727,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") {
@@ -467,14 +802,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 }
 };
@@ -491,6 +847,15 @@ 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 ?? [];
+}
 
 // src/file-types.ts
 var BINARY_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -538,6 +903,24 @@ var BINARY_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "aac",
   "opus",
   "pdf",
+  // Office / document containers
+  "xls",
+  "xlsx",
+  "xlsm",
+  "xlsb",
+  "doc",
+  "docx",
+  "docm",
+  "ppt",
+  "pptx",
+  "pptm",
+  "odt",
+  "ods",
+  "odp",
+  "pages",
+  "numbers",
+  "key",
+  "epub",
   // Fonts
   "woff",
   "woff2",
@@ -605,28 +988,92 @@ var BINARY_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "nc",
   "tfrecord"
 ]);
-function isBinaryFilePath(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot < 0) return false;
+var BINARY_FILE_TRANSIENT_SUFFIXES = /* @__PURE__ */ new Set([
+  "part",
+  "partial",
+  "crdownload",
+  "download"
+]);
+var BINARY_FILE_BASENAMES = /* @__PURE__ */ new Set([
+  "aapt",
+  "aapt2",
+  "adb",
+  "apksigner",
+  "bcc_compat",
+  "dexdump",
+  "dmtracedump",
+  "etc1tool",
+  "fastboot",
+  "hprof-conv",
+  "llvm-rs-cc",
+  "mksdcard",
+  "qemu-aarch64-static",
+  "qemu-arm-static",
+  "qemu-i386-static",
+  "qemu-x86_64-static",
+  "split-select",
+  "sqlite3",
+  "zipalign"
+]);
+function basenameOf(path) {
   const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
-  if (dot < slash) return false;
-  return BINARY_FILE_EXTENSIONS.has(path.slice(dot + 1).toLowerCase());
+  return path.slice(slash + 1);
+}
+function extensionOfBasename(basename) {
+  const dot = basename.lastIndexOf(".");
+  if (dot <= 0 || dot === basename.length - 1) return null;
+  return basename.slice(dot + 1).toLowerCase();
+}
+function isBinaryFilePath(path) {
+  let basename = basenameOf(path).toLowerCase();
+  if (BINARY_FILE_BASENAMES.has(basename)) return true;
+  for (let i = 0; i < 2; i++) {
+    const ext = extensionOfBasename(basename);
+    if (!ext) return false;
+    if (BINARY_FILE_EXTENSIONS.has(ext)) return true;
+    if (!BINARY_FILE_TRANSIENT_SUFFIXES.has(ext)) return false;
+    basename = basename.slice(0, -(ext.length + 1));
+  }
+  return false;
+}
+function isBinaryBuffer(bytes, inspectBytes = 8192) {
+  const head = bytes.subarray(0, Math.min(bytes.length, inspectBytes));
+  if (head.includes(0)) return true;
+  const startsWith = (...signature) => signature.every((value, index) => head[index] === value);
+  const ascii = (value) => Array.from(value).every(
+    (char, index) => head[index] === char.charCodeAt(0)
+  );
+  return startsWith(80, 75, 3, 4) || startsWith(80, 75, 5, 6) || startsWith(208, 207, 17, 224, 161, 177, 26, 225) || ascii("%PDF-") || startsWith(137, 80, 78, 71, 13, 10, 26, 10) || startsWith(255, 216, 255) || startsWith(71, 73, 70, 56) || startsWith(82, 73, 70, 70);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BINARY_FILE_BASENAMES,
   BINARY_FILE_EXTENSIONS,
+  BINARY_FILE_TRANSIENT_SUFFIXES,
   StreamBufferStore,
   TECH_STACK_REGISTRY,
+  TURN_COMPLETE_EVENT_TYPE,
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
   createBufferingTransform,
   createLogger,
+  emitLogToSink,
+  encodeTurnCompleteFrame,
+  encodeTurnSeqFrame,
   extractUserText,
   findLastUserMessage,
+  getDeclaredPorts,
+  getMinimumInstanceSize,
   getStackEntry,
   initInstrumentation,
+  isBinaryBuffer,
   isBinaryFilePath,
+  isDockerTechStack,
   isMacOSJunkName,
   isMacOSJunkPath,
   isMobileTechStack,
+  setOtelLogSink,
+  setTraceContextProvider,
   shutdownInstrumentation,
   stackSeedsItself,
   traceOperation,

package/dist/index.d.cts

@@ -1,8 +1,8 @@
-export { LogLevel, Logger, createLogger } from './logger.cjs';
+export { LogEntry, LogLevel, LogSink, Logger, TraceContext, TraceContextProvider, createLogger, emitLogToSink, setOtelLogSink, setTraceContextProvider } from './logger.cjs';
 export { InstrumentationConfig, initInstrumentation, shutdownInstrumentation, traceOperation } from './instrumentation.cjs';
-export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TurnSnapshot, TurnStatus, TurnTerminal, createBufferingTransform } from './stream-buffer.cjs';
+export { ReplayOptions, StreamBufferStore, StreamBufferWriter, TURN_COMPLETE_EVENT_TYPE, TURN_SEQ_EVENT_TYPE, TurnCompleteFrameData, TurnReply, TurnSnapshot, TurnStatus, TurnTerminal, compactSseFrames, createBufferingTransform, encodeTurnCompleteFrame, encodeTurnSeqFrame } from './stream-buffer.cjs';
 export { extractUserText, findLastUserMessage } from './chat-message.cjs';
 export { isMacOSJunkName, isMacOSJunkPath } from './macos-junk.cjs';
-export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getStackEntry, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.cjs';
-export { BINARY_FILE_EXTENSIONS, isBinaryFilePath } from './file-types.cjs';
+export { StackRegistryEntry, StackTarget, TECH_STACK_REGISTRY, getDeclaredPorts, getMinimumInstanceSize, getStackEntry, isDockerTechStack, isMobileTechStack, stackSeedsItself, usesMetroBundler } from './tech-stack-registry.cjs';
+export { BINARY_FILE_BASENAMES, BINARY_FILE_EXTENSIONS, BINARY_FILE_TRANSIENT_SUFFIXES, isBinaryBuffer, isBinaryFilePath } from './file-types.cjs';
 import '@opentelemetry/api';