@jdi-code/claude-code 1.0.3

package/dist/chunk-91rcbmch.js

@@ -0,0 +1,440 @@
+// @bun
+import {
+  LogSelector,
+  agenticSessionSearch,
+  checkCrossProjectResume,
+  init_LogSelector,
+  init_agenticSessionSearch,
+  init_crossProjectResume
+} from "./chunk-0pjw8y9z.js";
+import"./chunk-drrw55jr.js";
+import"./chunk-rnjbczcy.js";
+import"./chunk-y18mc4m4.js";
+import"./chunk-z4dm354d.js";
+import"./chunk-ycxwftfh.js";
+import"./chunk-v496te8v.js";
+import"./chunk-f1rrxxcf.js";
+import"./chunk-m5c8ng6v.js";
+import"./chunk-b0eez8w0.js";
+import"./chunk-4anyx5bv.js";
+import"./chunk-x5j50p5x.js";
+import {
+  MessageResponse,
+  Spinner,
+  getLastSessionLog,
+  getSessionIdFromLog,
+  getWorktreePaths,
+  init_MessageResponse,
+  init_Spinner,
+  init_getWorktreePaths,
+  init_sessionStorage,
+  init_uuid,
+  isCustomTitleEnabled,
+  isLiteLog,
+  loadAllProjectsMessageLogs,
+  loadFullLog,
+  loadSameRepoMessageLogs,
+  searchSessionsByCustomTitle,
+  validateUuid
+} from "./chunk-5frcqxsv.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-gb2q3nvc.js";
+import"./chunk-neh2frnn.js";
+import"./chunk-q6b51yc5.js";
+import"./chunk-gfkppe34.js";
+import"./chunk-kqd0e3xj.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-xe6z85xc.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-pxrffn0w.js";
+import"./chunk-0nt9md2b.js";
+import"./chunk-rn4kqfvd.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-n8sjmqba.js";
+import"./chunk-9e2kqv5g.js";
+import {
+  init_modalContext,
+  init_useTerminalSize,
+  useIsInsideModal,
+  useTerminalSize
+} from "./chunk-g653q217.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  init_osc,
+  require_compiler_runtime,
+  setClipboard
+} from "./chunk-z72st5c8.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-35x3tjnr.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-40b8p5em.js";
+import"./chunk-s0xfxkys.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import {
+  init_source,
+  source_default
+} from "./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-hx2tr4ep.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import {
+  getOriginalCwd,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/resume/resume.tsx
+function resumeHelpMessage(result) {
+  switch (result.resultType) {
+    case "sessionNotFound":
+      return `Session ${source_default.bold(result.arg)} was not found.`;
+    case "multipleMatches":
+      return `Found ${result.count} sessions matching ${source_default.bold(result.arg)}. Please use /resume to pick a specific session.`;
+  }
+}
+function ResumeError(t0) {
+  const $ = import_compiler_runtime.c(10);
+  const {
+    message,
+    args,
+    onDone
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onDone) {
+    t1 = () => {
+      const timer = setTimeout(onDone, 0);
+      return () => clearTimeout(timer);
+    };
+    t2 = [onDone];
+    $[0] = onDone;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  React.useEffect(t1, t2);
+  let t3;
+  if ($[3] !== args) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        figures_default.pointer,
+        " /resume ",
+        args
+      ]
+    }, undefined, true, undefined, this);
+    $[3] = args;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== message) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(MessageResponse, {
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: message
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+    $[5] = message;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== t3 || $[8] !== t4) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      children: [
+        t3,
+        t4
+      ]
+    }, undefined, true, undefined, this);
+    $[7] = t3;
+    $[8] = t4;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  return t5;
+}
+function ResumeCommand({
+  onDone,
+  onResume
+}) {
+  const [logs, setLogs] = React.useState([]);
+  const [worktreePaths, setWorktreePaths] = React.useState([]);
+  const [loading, setLoading] = React.useState(true);
+  const [resuming, setResuming] = React.useState(false);
+  const [showAllProjects, setShowAllProjects] = React.useState(false);
+  const {
+    rows
+  } = useTerminalSize();
+  const insideModal = useIsInsideModal();
+  const loadLogs = React.useCallback(async (allProjects, paths) => {
+    setLoading(true);
+    try {
+      const allLogs = allProjects ? await loadAllProjectsMessageLogs() : await loadSameRepoMessageLogs(paths);
+      const resumable = filterResumableSessions(allLogs, getSessionId());
+      if (resumable.length === 0) {
+        onDone("No conversations found to resume");
+        return;
+      }
+      setLogs(resumable);
+    } catch (_err) {
+      onDone("Failed to load conversations");
+    } finally {
+      setLoading(false);
+    }
+  }, [onDone]);
+  React.useEffect(() => {
+    async function init() {
+      const paths_0 = await getWorktreePaths(getOriginalCwd());
+      setWorktreePaths(paths_0);
+      loadLogs(false, paths_0);
+    }
+    init();
+  }, [loadLogs]);
+  const handleToggleAllProjects = React.useCallback(() => {
+    const newValue = !showAllProjects;
+    setShowAllProjects(newValue);
+    loadLogs(newValue, worktreePaths);
+  }, [showAllProjects, loadLogs, worktreePaths]);
+  async function handleSelect(log) {
+    const sessionId = validateUuid(getSessionIdFromLog(log));
+    if (!sessionId) {
+      onDone("Failed to resume conversation");
+      return;
+    }
+    const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+    const crossProjectCheck = checkCrossProjectResume(fullLog, showAllProjects, worktreePaths);
+    if (crossProjectCheck.isCrossProject) {
+      if (crossProjectCheck.isSameRepoWorktree) {
+        setResuming(true);
+        onResume(sessionId, fullLog, "slash_command_picker");
+        return;
+      }
+      const crossCmd = crossProjectCheck.command;
+      const raw = await setClipboard(crossCmd);
+      if (raw)
+        process.stdout.write(raw);
+      const message = ["", "This conversation is from a different directory.", "", "To resume, run:", `  ${crossCmd}`, "", "(Command copied to clipboard)", ""].join(`
+`);
+      onDone(message, {
+        display: "user"
+      });
+      return;
+    }
+    setResuming(true);
+    onResume(sessionId, fullLog, "slash_command_picker");
+  }
+  function handleCancel() {
+    onDone("Resume cancelled", {
+      display: "system"
+    });
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Spinner, {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: " Loading conversations\u2026"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  if (resuming) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Spinner, {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: " Resuming conversation\u2026"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(LogSelector, {
+    logs,
+    maxHeight: insideModal ? Math.floor(rows / 2) : rows - 2,
+    onCancel: handleCancel,
+    onSelect: handleSelect,
+    onLogsChanged: () => loadLogs(showAllProjects, worktreePaths),
+    showAllProjects,
+    onToggleAllProjects: handleToggleAllProjects,
+    onAgenticSearch: agenticSessionSearch
+  }, undefined, false, undefined, this);
+}
+function filterResumableSessions(logs, currentSessionId) {
+  return logs.filter((l) => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId);
+}
+var import_compiler_runtime, React, jsx_dev_runtime, call = async (onDone, context, args) => {
+  const onResume = async (sessionId, log, entrypoint) => {
+    try {
+      await context.resume?.(sessionId, log, entrypoint);
+      onDone(undefined, {
+        display: "skip"
+      });
+    } catch (error) {
+      logError(error);
+      onDone(`Failed to resume: ${error.message}`);
+    }
+  };
+  const arg = args?.trim();
+  if (!arg) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ResumeCommand, {
+      onDone,
+      onResume
+    }, Date.now(), false, undefined, this);
+  }
+  const worktreePaths = await getWorktreePaths(getOriginalCwd());
+  const logs = await loadSameRepoMessageLogs(worktreePaths);
+  if (logs.length === 0) {
+    const message2 = "No conversations found to resume.";
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ResumeError, {
+      message: message2,
+      args: arg,
+      onDone: () => onDone(message2)
+    }, undefined, false, undefined, this);
+  }
+  const maybeSessionId = validateUuid(arg);
+  if (maybeSessionId) {
+    const matchingLogs = logs.filter((l) => getSessionIdFromLog(l) === maybeSessionId).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    if (matchingLogs.length > 0) {
+      const log = matchingLogs[0];
+      const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+      onResume(maybeSessionId, fullLog, "slash_command_session_id");
+      return null;
+    }
+    const directLog = await getLastSessionLog(maybeSessionId);
+    if (directLog) {
+      onResume(maybeSessionId, directLog, "slash_command_session_id");
+      return null;
+    }
+  }
+  if (isCustomTitleEnabled()) {
+    const titleMatches = await searchSessionsByCustomTitle(arg, {
+      exact: true
+    });
+    if (titleMatches.length === 1) {
+      const log = titleMatches[0];
+      const sessionId = getSessionIdFromLog(log);
+      if (sessionId) {
+        const fullLog = isLiteLog(log) ? await loadFullLog(log) : log;
+        onResume(sessionId, fullLog, "slash_command_title");
+        return null;
+      }
+    }
+    if (titleMatches.length > 1) {
+      const message2 = resumeHelpMessage({
+        resultType: "multipleMatches",
+        arg,
+        count: titleMatches.length
+      });
+      return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ResumeError, {
+        message: message2,
+        args: arg,
+        onDone: () => onDone(message2)
+      }, undefined, false, undefined, this);
+    }
+  }
+  const message = resumeHelpMessage({
+    resultType: "sessionNotFound",
+    arg
+  });
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ResumeError, {
+    message,
+    args: arg,
+    onDone: () => onDone(message)
+  }, undefined, false, undefined, this);
+};
+var init_resume = __esm(() => {
+  init_source();
+  init_figures();
+  init_state();
+  init_LogSelector();
+  init_MessageResponse();
+  init_Spinner();
+  init_modalContext();
+  init_useTerminalSize();
+  init_osc();
+  init_ink();
+  init_agenticSessionSearch();
+  init_crossProjectResume();
+  init_getWorktreePaths();
+  init_log();
+  init_sessionStorage();
+  init_uuid();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  React = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_resume();
+
+export {
+  filterResumableSessions,
+  call
+};

package/dist/chunk-96awg5tc.js

@@ -0,0 +1,276 @@
+// @bun
+import {
+  CCRClient,
+  SSETransport
+} from "./chunk-e5ga3s0y.js";
+import {
+  registerWorker
+} from "./chunk-cvy3vntc.js";
+import {
+  init_bridgeEnabled
+} from "./chunk-74v9z7z4.js";
+import {
+  init_sessionIngressAuth,
+  updateSessionIngressAuthToken
+} from "./chunk-gb2q3nvc.js";
+import {
+  init_semver,
+  lt
+} from "./chunk-ps49ymvj.js";
+import {
+  getFeatureValue_DEPRECATED,
+  init_growthbook
+} from "./chunk-53nbpp47.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+
+// src/bridge/envLessBridgeConfig.ts
+init_v4();
+init_growthbook();
+init_lazySchema();
+init_semver();
+init_bridgeEnabled();
+var DEFAULT_ENV_LESS_BRIDGE_CONFIG = {
+  init_retry_max_attempts: 3,
+  init_retry_base_delay_ms: 500,
+  init_retry_jitter_fraction: 0.25,
+  init_retry_max_delay_ms: 4000,
+  http_timeout_ms: 1e4,
+  uuid_dedup_buffer_size: 2000,
+  heartbeat_interval_ms: 20000,
+  heartbeat_jitter_fraction: 0.1,
+  token_refresh_buffer_ms: 300000,
+  teardown_archive_timeout_ms: 1500,
+  connect_timeout_ms: 15000,
+  min_version: "0.0.0",
+  should_show_app_upgrade_message: false
+};
+var envLessBridgeConfigSchema = lazySchema(() => exports_external.object({
+  init_retry_max_attempts: exports_external.number().int().min(1).max(10).default(3),
+  init_retry_base_delay_ms: exports_external.number().int().min(100).default(500),
+  init_retry_jitter_fraction: exports_external.number().min(0).max(1).default(0.25),
+  init_retry_max_delay_ms: exports_external.number().int().min(500).default(4000),
+  http_timeout_ms: exports_external.number().int().min(2000).default(1e4),
+  uuid_dedup_buffer_size: exports_external.number().int().min(100).max(50000).default(2000),
+  heartbeat_interval_ms: exports_external.number().int().min(5000).max(30000).default(20000),
+  heartbeat_jitter_fraction: exports_external.number().min(0).max(0.5).default(0.1),
+  token_refresh_buffer_ms: exports_external.number().int().min(30000).max(1800000).default(300000),
+  teardown_archive_timeout_ms: exports_external.number().int().min(500).max(2000).default(1500),
+  connect_timeout_ms: exports_external.number().int().min(5000).max(60000).default(15000),
+  min_version: exports_external.string().refine((v) => {
+    try {
+      lt(v, "0.0.0");
+      return true;
+    } catch {
+      return false;
+    }
+  }).default("0.0.0"),
+  should_show_app_upgrade_message: exports_external.boolean().default(false)
+}));
+async function getEnvLessBridgeConfig() {
+  const raw = await getFeatureValue_DEPRECATED("tengu_bridge_repl_v2_config", DEFAULT_ENV_LESS_BRIDGE_CONFIG);
+  const parsed = envLessBridgeConfigSchema().safeParse(raw);
+  return parsed.success ? parsed.data : DEFAULT_ENV_LESS_BRIDGE_CONFIG;
+}
+async function checkEnvLessBridgeMinVersion() {
+  const cfg = await getEnvLessBridgeConfig();
+  if (cfg.min_version && lt(MACRO.VERSION, cfg.min_version)) {
+    return `Your version of Claude Code (${MACRO.VERSION}) is too old for Remote Control.
+Version ${cfg.min_version} or higher is required. Run \`claude update\` to update.`;
+  }
+  return null;
+}
+
+// src/bridge/replBridgeTransport.ts
+init_debug();
+init_errors();
+init_sessionIngressAuth();
+function createV1ReplTransport(hybrid) {
+  return {
+    write: (msg) => hybrid.write(msg),
+    writeBatch: (msgs) => hybrid.writeBatch(msgs),
+    close: () => hybrid.close(),
+    isConnectedStatus: () => hybrid.isConnectedStatus(),
+    getStateLabel: () => hybrid.getStateLabel(),
+    setOnData: (cb) => hybrid.setOnData(cb),
+    setOnClose: (cb) => hybrid.setOnClose(cb),
+    setOnConnect: (cb) => hybrid.setOnConnect(cb),
+    connect: () => void hybrid.connect(),
+    getLastSequenceNum: () => 0,
+    get droppedBatchCount() {
+      return hybrid.droppedBatchCount;
+    },
+    reportState: () => {},
+    reportMetadata: () => {},
+    reportDelivery: () => {},
+    flush: () => Promise.resolve()
+  };
+}
+async function createV2ReplTransport(opts) {
+  const {
+    sessionUrl,
+    ingressToken,
+    sessionId,
+    initialSequenceNum,
+    getAuthToken
+  } = opts;
+  let getAuthHeaders;
+  if (getAuthToken) {
+    getAuthHeaders = () => {
+      const token = getAuthToken();
+      if (!token)
+        return {};
+      return { Authorization: `Bearer ${token}` };
+    };
+  } else {
+    updateSessionIngressAuthToken(ingressToken);
+  }
+  const epoch = opts.epoch ?? await registerWorker(sessionUrl, ingressToken);
+  logForDebugging(`[bridge:repl] CCR v2: worker sessionId=${sessionId} epoch=${epoch}${opts.epoch !== undefined ? " (from /bridge)" : " (via registerWorker)"}`);
+  const sseUrl = new URL(sessionUrl);
+  sseUrl.pathname = sseUrl.pathname.replace(/\/$/, "") + "/worker/events/stream";
+  const sse = new SSETransport(sseUrl, {}, sessionId, undefined, initialSequenceNum, getAuthHeaders);
+  let onCloseCb;
+  const ccr = new CCRClient(sse, new URL(sessionUrl), {
+    getAuthHeaders,
+    heartbeatIntervalMs: opts.heartbeatIntervalMs,
+    heartbeatJitterFraction: opts.heartbeatJitterFraction,
+    onEpochMismatch: () => {
+      logForDebugging("[bridge:repl] CCR v2: epoch superseded (409) \u2014 closing for poll-loop recovery");
+      try {
+        ccr.close();
+        sse.close();
+        onCloseCb?.(4090);
+      } catch (closeErr) {
+        logForDebugging(`[bridge:repl] CCR v2: error during epoch-mismatch cleanup: ${errorMessage(closeErr)}`, { level: "error" });
+      }
+      throw new Error("epoch superseded");
+    }
+  });
+  sse.setOnEvent((event) => {
+    ccr.reportDelivery(event.event_id, "received");
+    ccr.reportDelivery(event.event_id, "processed");
+  });
+  let onConnectCb;
+  let ccrInitialized = false;
+  let closed = false;
+  return {
+    write(msg) {
+      return ccr.writeEvent(msg);
+    },
+    async writeBatch(msgs) {
+      for (const m of msgs) {
+        if (closed)
+          break;
+        await ccr.writeEvent(m);
+      }
+    },
+    close() {
+      closed = true;
+      ccr.close();
+      sse.close();
+    },
+    isConnectedStatus() {
+      return ccrInitialized;
+    },
+    getStateLabel() {
+      if (sse.isClosedStatus())
+        return "closed";
+      if (sse.isConnectedStatus())
+        return ccrInitialized ? "connected" : "init";
+      return "connecting";
+    },
+    setOnData(cb) {
+      sse.setOnData(cb);
+    },
+    setOnClose(cb) {
+      onCloseCb = cb;
+      sse.setOnClose((code) => {
+        ccr.close();
+        cb(code ?? 4092);
+      });
+    },
+    setOnConnect(cb) {
+      onConnectCb = cb;
+    },
+    getLastSequenceNum() {
+      return sse.getLastSequenceNum();
+    },
+    droppedBatchCount: 0,
+    reportState(state) {
+      ccr.reportState(state);
+    },
+    reportMetadata(metadata) {
+      ccr.reportMetadata(metadata);
+    },
+    reportDelivery(eventId, status) {
+      ccr.reportDelivery(eventId, status);
+    },
+    flush() {
+      return ccr.flush();
+    },
+    connect() {
+      if (!opts.outboundOnly) {
+        sse.connect();
+      }
+      ccr.initialize(epoch).then(() => {
+        ccrInitialized = true;
+        logForDebugging(`[bridge:repl] v2 transport ready for writes (epoch=${epoch}, sse=${sse.isConnectedStatus() ? "open" : "opening"})`);
+        onConnectCb?.();
+      }, (err) => {
+        logForDebugging(`[bridge:repl] CCR v2 initialize failed: ${errorMessage(err)}`, { level: "error" });
+        ccr.close();
+        sse.close();
+        onCloseCb?.(4091);
+      });
+    }
+  };
+}
+
+// src/bridge/flushGate.ts
+class FlushGate {
+  _active = false;
+  _pending = [];
+  get active() {
+    return this._active;
+  }
+  get pendingCount() {
+    return this._pending.length;
+  }
+  start() {
+    this._active = true;
+  }
+  end() {
+    this._active = false;
+    return this._pending.splice(0);
+  }
+  enqueue(...items) {
+    if (!this._active)
+      return false;
+    this._pending.push(...items);
+    return true;
+  }
+  drop() {
+    this._active = false;
+    const count = this._pending.length;
+    this._pending.length = 0;
+    return count;
+  }
+  deactivate() {
+    this._active = false;
+  }
+}
+
+export { getEnvLessBridgeConfig, checkEnvLessBridgeMinVersion, createV1ReplTransport, createV2ReplTransport, FlushGate };