@costrict/csc 4.0.1

package/dist/chunk-f77bmbss.js

@@ -0,0 +1,262 @@
+// @bun
+import {
+  getDesktopPath,
+  init_file
+} from "./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-z6e5jp2w.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/heapDumpService.ts
+import { createWriteStream, writeFileSync } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import {
+  getHeapSnapshot,
+  getHeapSpaceStatistics,
+  getHeapStatistics
+} from "v8";
+async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
+  const usage = process.memoryUsage();
+  const heapStats = getHeapStatistics();
+  const resourceUsage = process.resourceUsage();
+  const uptimeSeconds = process.uptime();
+  let heapSpaceStats;
+  try {
+    heapSpaceStats = getHeapSpaceStatistics();
+  } catch {}
+  const activeHandles = process._getActiveHandles().length;
+  const activeRequests = process._getActiveRequests().length;
+  let openFileDescriptors;
+  try {
+    openFileDescriptors = (await readdir("/proc/self/fd")).length;
+  } catch {}
+  let smapsRollup;
+  try {
+    smapsRollup = await readFile("/proc/self/smaps_rollup", "utf8");
+  } catch {}
+  const nativeMemory = usage.rss - usage.heapUsed;
+  const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
+  const mbPerHour = bytesPerSecond * 3600 / (1024 * 1024);
+  const potentialLeaks = [];
+  if (heapStats.number_of_detached_contexts > 0) {
+    potentialLeaks.push(`${heapStats.number_of_detached_contexts} detached context(s) - possible iframe/context leak`);
+  }
+  if (activeHandles > 100) {
+    potentialLeaks.push(`${activeHandles} active handles - possible timer/socket leak`);
+  }
+  if (nativeMemory > usage.heapUsed) {
+    potentialLeaks.push("Native memory > heap - leak may be in native addons (node-pty, sharp, etc.)");
+  }
+  if (mbPerHour > 100) {
+    potentialLeaks.push(`High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`);
+  }
+  if (openFileDescriptors && openFileDescriptors > 500) {
+    potentialLeaks.push(`${openFileDescriptors} open file descriptors - possible file/socket leak`);
+  }
+  return {
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    trigger,
+    dumpNumber,
+    uptimeSeconds,
+    memoryUsage: {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      external: usage.external,
+      arrayBuffers: usage.arrayBuffers,
+      rss: usage.rss
+    },
+    memoryGrowthRate: {
+      bytesPerSecond,
+      mbPerHour
+    },
+    v8HeapStats: {
+      heapSizeLimit: heapStats.heap_size_limit,
+      mallocedMemory: heapStats.malloced_memory,
+      peakMallocedMemory: heapStats.peak_malloced_memory,
+      detachedContexts: heapStats.number_of_detached_contexts,
+      nativeContexts: heapStats.number_of_native_contexts
+    },
+    v8HeapSpaces: heapSpaceStats?.map((space) => ({
+      name: space.space_name,
+      size: space.space_size,
+      used: space.space_used_size,
+      available: space.space_available_size
+    })),
+    resourceUsage: {
+      maxRSS: resourceUsage.maxRSS * 1024,
+      userCPUTime: resourceUsage.userCPUTime,
+      systemCPUTime: resourceUsage.systemCPUTime
+    },
+    activeHandles,
+    activeRequests,
+    openFileDescriptors,
+    analysis: {
+      potentialLeaks,
+      recommendation: potentialLeaks.length > 0 ? `WARNING: ${potentialLeaks.length} potential leak indicator(s) found. See potentialLeaks array.` : "No obvious leak indicators. Check heap snapshot for retained objects."
+    },
+    smapsRollup,
+    platform: process.platform,
+    nodeVersion: process.version,
+    ccVersion: "4.0.1"
+  };
+}
+async function performHeapDump(trigger = "manual", dumpNumber = 0) {
+  try {
+    const sessionId = getSessionId();
+    const diagnostics = await captureMemoryDiagnostics(trigger, dumpNumber);
+    const toGB = (bytes) => (bytes / 1024 / 1024 / 1024).toFixed(3);
+    logForDebugging(`[HeapDump] Memory state:
+  heapUsed: ${toGB(diagnostics.memoryUsage.heapUsed)} GB (in snapshot)
+  external: ${toGB(diagnostics.memoryUsage.external)} GB (NOT in snapshot)
+  rss: ${toGB(diagnostics.memoryUsage.rss)} GB (total process)
+  ${diagnostics.analysis.recommendation}`);
+    const dumpDir = getDesktopPath();
+    await getFsImplementation().mkdir(dumpDir);
+    const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : "";
+    const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
+    const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
+    const heapPath = join(dumpDir, heapFilename);
+    const diagPath = join(dumpDir, diagFilename);
+    await writeFile(diagPath, jsonStringify(diagnostics, null, 2), {
+      mode: 384
+    });
+    logForDebugging(`[HeapDump] Diagnostics written to ${diagPath}`);
+    await writeHeapSnapshot(heapPath);
+    logForDebugging(`[HeapDump] Heap dump written to ${heapPath}`);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: true
+    });
+    return { success: true, heapPath, diagPath };
+  } catch (err) {
+    const error = toError(err);
+    logError(error);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: false
+    });
+    return { success: false, error: error.message };
+  }
+}
+async function writeHeapSnapshot(filepath) {
+  if (typeof Bun !== "undefined") {
+    writeFileSync(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
+      mode: 384
+    });
+    Bun.gc(true);
+    return;
+  }
+  const writeStream = createWriteStream(filepath, { mode: 384 });
+  const heapSnapshotStream = getHeapSnapshot();
+  await pipeline(heapSnapshotStream, writeStream);
+}
+var init_heapDumpService = __esm(() => {
+  init_state();
+  init_analytics();
+  init_debug();
+  init_errors();
+  init_file();
+  init_fsOperations();
+  init_log();
+  init_slowOperations();
+});
+
+// src/commands/heapdump/heapdump.ts
+async function call() {
+  const result = await performHeapDump();
+  if (!result.success) {
+    return {
+      type: "text",
+      value: `Failed to create heap dump: ${result.error}`
+    };
+  }
+  return {
+    type: "text",
+    value: `${result.heapPath}
+${result.diagPath}`
+  };
+}
+var init_heapdump = __esm(() => {
+  init_heapDumpService();
+});
+init_heapdump();
+
+export {
+  call
+};

package/dist/chunk-fafwc5w7.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  getFeatureValue_CACHED_WITH_REFRESH,
+  init_growthbook
+} from "./chunk-qp1047f9.js";
+import {
+  init_lazySchema,
+  lazySchema
+} from "./chunk-64c1avct.js";
+import {
+  init_v4
+} from "./chunk-4pbx3g7s.js";
+import {
+  exports_external
+} from "./chunk-26wtxbdc.js";
+
+// src/bridge/pollConfig.ts
+init_v4();
+init_growthbook();
+init_lazySchema();
+
+// src/bridge/pollConfigDefaults.ts
+var POLL_INTERVAL_MS_NOT_AT_CAPACITY = 2000;
+var POLL_INTERVAL_MS_AT_CAPACITY = 600000;
+var MULTISESSION_POLL_INTERVAL_MS_NOT_AT_CAPACITY = POLL_INTERVAL_MS_NOT_AT_CAPACITY;
+var MULTISESSION_POLL_INTERVAL_MS_PARTIAL_CAPACITY = POLL_INTERVAL_MS_NOT_AT_CAPACITY;
+var MULTISESSION_POLL_INTERVAL_MS_AT_CAPACITY = POLL_INTERVAL_MS_AT_CAPACITY;
+var DEFAULT_POLL_CONFIG = {
+  poll_interval_ms_not_at_capacity: POLL_INTERVAL_MS_NOT_AT_CAPACITY,
+  poll_interval_ms_at_capacity: POLL_INTERVAL_MS_AT_CAPACITY,
+  non_exclusive_heartbeat_interval_ms: 0,
+  multisession_poll_interval_ms_not_at_capacity: MULTISESSION_POLL_INTERVAL_MS_NOT_AT_CAPACITY,
+  multisession_poll_interval_ms_partial_capacity: MULTISESSION_POLL_INTERVAL_MS_PARTIAL_CAPACITY,
+  multisession_poll_interval_ms_at_capacity: MULTISESSION_POLL_INTERVAL_MS_AT_CAPACITY,
+  reclaim_older_than_ms: 5000,
+  session_keepalive_interval_v2_ms: 120000
+};
+
+// src/bridge/pollConfig.ts
+var zeroOrAtLeast100 = {
+  message: "must be 0 (disabled) or \u2265100ms"
+};
+var pollIntervalConfigSchema = lazySchema(() => exports_external.object({
+  poll_interval_ms_not_at_capacity: exports_external.number().int().min(100),
+  poll_interval_ms_at_capacity: exports_external.number().int().refine((v) => v === 0 || v >= 100, zeroOrAtLeast100),
+  non_exclusive_heartbeat_interval_ms: exports_external.number().int().min(0).default(0),
+  multisession_poll_interval_ms_not_at_capacity: exports_external.number().int().min(100).default(DEFAULT_POLL_CONFIG.multisession_poll_interval_ms_not_at_capacity),
+  multisession_poll_interval_ms_partial_capacity: exports_external.number().int().min(100).default(DEFAULT_POLL_CONFIG.multisession_poll_interval_ms_partial_capacity),
+  multisession_poll_interval_ms_at_capacity: exports_external.number().int().refine((v) => v === 0 || v >= 100, zeroOrAtLeast100).default(DEFAULT_POLL_CONFIG.multisession_poll_interval_ms_at_capacity),
+  reclaim_older_than_ms: exports_external.number().int().min(1).default(5000),
+  session_keepalive_interval_v2_ms: exports_external.number().int().min(0).default(120000)
+}).refine((cfg) => cfg.non_exclusive_heartbeat_interval_ms > 0 || cfg.poll_interval_ms_at_capacity > 0, {
+  message: "at-capacity liveness requires non_exclusive_heartbeat_interval_ms > 0 or poll_interval_ms_at_capacity > 0"
+}).refine((cfg) => cfg.non_exclusive_heartbeat_interval_ms > 0 || cfg.multisession_poll_interval_ms_at_capacity > 0, {
+  message: "at-capacity liveness requires non_exclusive_heartbeat_interval_ms > 0 or multisession_poll_interval_ms_at_capacity > 0"
+}));
+function getPollIntervalConfig() {
+  const raw = getFeatureValue_CACHED_WITH_REFRESH("tengu_bridge_poll_interval_config", DEFAULT_POLL_CONFIG, 5 * 60 * 1000);
+  const parsed = pollIntervalConfigSchema().safeParse(raw);
+  return parsed.success ? parsed.data : DEFAULT_POLL_CONFIG;
+}
+
+export { DEFAULT_POLL_CONFIG, getPollIntervalConfig };

package/dist/chunk-fas0j37w.js

@@ -0,0 +1,206 @@
+// @bun
+import {
+  CCRClient
+} from "./chunk-7ethp9j4.js";
+import {
+  registerWorker
+} from "./chunk-p99pzx02.js";
+import {
+  SSETransport,
+  init_SSETransport
+} from "./chunk-m85hmjj5.js";
+import {
+  init_sessionIngressAuth,
+  updateSessionIngressAuthToken
+} from "./chunk-3x2jaxpw.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
+
+// src/bridge/replBridgeTransport.ts
+init_SSETransport();
+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 { createV1ReplTransport, createV2ReplTransport, FlushGate };

package/dist/chunk-fbv4apne.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/process.ts
+function handleEPIPE(stream) {
+  return (err) => {
+    if (err.code === "EPIPE") {
+      stream.destroy();
+    }
+  };
+}
+function registerProcessOutputErrorHandlers() {
+  process.stdout.on("error", handleEPIPE(process.stdout));
+  process.stderr.on("error", handleEPIPE(process.stderr));
+}
+function writeOut(stream, data) {
+  if (stream.destroyed) {
+    return;
+  }
+  stream.write(data);
+}
+function writeToStdout(data) {
+  writeOut(process.stdout, data);
+}
+function writeToStderr(data) {
+  writeOut(process.stderr, data);
+}
+function exitWithError(message) {
+  console.error(message);
+  process.exit(1);
+}
+function peekForStdinData(stream, ms) {
+  return new Promise((resolve) => {
+    const done = (timedOut) => {
+      clearTimeout(peek);
+      stream.off("end", onEnd);
+      stream.off("data", onFirstData);
+      resolve(timedOut);
+    };
+    const onEnd = () => done(false);
+    const onFirstData = () => clearTimeout(peek);
+    const peek = setTimeout(done, ms, true);
+    stream.once("end", onEnd);
+    stream.once("data", onFirstData);
+  });
+}
+var init_process = () => {};
+
+export { registerProcessOutputErrorHandlers, writeToStdout, writeToStderr, exitWithError, peekForStdinData, init_process };

package/dist/chunk-fbvwrs77.js

@@ -0,0 +1,74 @@
+// @bun
+import {
+  ReadBuffer,
+  init_stdio,
+  serializeMessage
+} from "./chunk-z915v06p.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process from "process";
+
+class StdioServerTransport {
+  constructor(_stdin = process.stdin, _stdout = process.stdout) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._readBuffer = new ReadBuffer;
+    this._started = false;
+    this._ondata = (chunk) => {
+      this._readBuffer.append(chunk);
+      this.processReadBuffer();
+    };
+    this._onerror = (error) => {
+      this.onerror?.(error);
+    };
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this._started = true;
+    this._stdin.on("data", this._ondata);
+    this._stdin.on("error", this._onerror);
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error);
+      }
+    }
+  }
+  async close() {
+    this._stdin.off("data", this._ondata);
+    this._stdin.off("error", this._onerror);
+    const remainingDataListeners = this._stdin.listenerCount("data");
+    if (remainingDataListeners === 0) {
+      this._stdin.pause();
+    }
+    this._readBuffer.clear();
+    this.onclose?.();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      const json = serializeMessage(message);
+      if (this._stdout.write(json)) {
+        resolve();
+      } else {
+        this._stdout.once("drain", resolve);
+      }
+    });
+  }
+}
+var init_stdio2 = __esm(() => {
+  init_stdio();
+});
+
+export { StdioServerTransport, init_stdio2 as init_stdio };

package/dist/chunk-feyzykye.js

@@ -0,0 +1,10 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// packages/url-handler-napi/src/index.ts
+async function waitForUrlEvent(timeoutMs) {
+  return null;
+}
+export {
+  waitForUrlEvent
+};