@jdi-code/claude-code 1.0.3 → 1.2.0

package/dist/{chunk-e5ga3s0y.js → chunk-86vec0h6.js}

@@ -1,7 +1,4 @@
 // @bun
-import {
-  decodeJwtExpiry
-} from "./chunk-eb90vwvr.js";
 import {
   getSessionIngressAuthHeaders,
   getSessionIngressAuthToken,
@@ -9,21 +6,27 @@ import {
   init_sessionIngressAuth,
   registerSessionActivityCallback,
   unregisterSessionActivityCallback
-} from "./chunk-gb2q3nvc.js";
+} from "./chunk-nea2sah6.js";
 import {
   getClaudeCodeUserAgent,
-  init_sleep,
-  init_userAgent,
-  sleep
-} from "./chunk-53nbpp47.js";
+  init_userAgent
+} from "./chunk-zhtrjznv.js";
 import {
   createAxiosInstance,
   init_proxy
-} from "./chunk-fw49pe3p.js";
+} from "./chunk-cztjpxq4.js";
+import {
+  init_sleep,
+  sleep
+} from "./chunk-8g5pe1gr.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
 import {
   init_diagLogs,
   logForDiagnosticsNoPII
-} from "./chunk-hrzerbfw.js";
+} from "./chunk-36b2q5fg.js";
 import {
   errorMessage,
   getErrnoCode,
@@ -33,11 +36,140 @@ import {
   jsonParse,
   jsonStringify,
   logForDebugging
-} from "./chunk-nxsh6de2.js";
-import {
-  axios_default,
-  init_axios
-} from "./chunk-xszk7n10.js";
+} from "./chunk-404qm8xt.js";
+
+// src/bridge/jwtUtils.ts
+init_analytics();
+init_debug();
+init_diagLogs();
+init_errors();
+init_slowOperations();
+function formatDuration(ms) {
+  if (ms < 60000)
+    return `${Math.round(ms / 1000)}s`;
+  const m = Math.floor(ms / 60000);
+  const s = Math.round(ms % 60000 / 1000);
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+function decodeJwtPayload(token) {
+  const jwt = token.startsWith("sk-ant-si-") ? token.slice("sk-ant-si-".length) : token;
+  const parts = jwt.split(".");
+  if (parts.length !== 3 || !parts[1])
+    return null;
+  try {
+    return jsonParse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function decodeJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (payload !== null && typeof payload === "object" && "exp" in payload && typeof payload.exp === "number") {
+    return payload.exp;
+  }
+  return null;
+}
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var FALLBACK_REFRESH_INTERVAL_MS = 30 * 60 * 1000;
+var MAX_REFRESH_FAILURES = 3;
+var REFRESH_RETRY_DELAY_MS = 60000;
+function createTokenRefreshScheduler({
+  getAccessToken,
+  onRefresh,
+  label,
+  refreshBufferMs = TOKEN_REFRESH_BUFFER_MS
+}) {
+  const timers = new Map;
+  const failureCounts = new Map;
+  const generations = new Map;
+  function nextGeneration(sessionId) {
+    const gen = (generations.get(sessionId) ?? 0) + 1;
+    generations.set(sessionId, gen);
+    return gen;
+  }
+  function schedule(sessionId, token) {
+    const expiry = decodeJwtExpiry(token);
+    if (!expiry) {
+      logForDebugging(`[${label}:token] Could not decode JWT expiry for sessionId=${sessionId}, token prefix=${token.slice(0, 15)}\u2026, keeping existing timer`);
+      return;
+    }
+    const existing = timers.get(sessionId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const gen = nextGeneration(sessionId);
+    const expiryDate = new Date(expiry * 1000).toISOString();
+    const delayMs = expiry * 1000 - Date.now() - refreshBufferMs;
+    if (delayMs <= 0) {
+      logForDebugging(`[${label}:token] Token for sessionId=${sessionId} expires=${expiryDate} (past or within buffer), refreshing immediately`);
+      doRefresh(sessionId, gen);
+      return;
+    }
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires=${expiryDate}, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  function scheduleFromExpiresIn(sessionId, expiresInSeconds) {
+    const existing = timers.get(sessionId);
+    if (existing)
+      clearTimeout(existing);
+    const gen = nextGeneration(sessionId);
+    const delayMs = Math.max(expiresInSeconds * 1000 - refreshBufferMs, 30000);
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires_in=${expiresInSeconds}s, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  async function doRefresh(sessionId, gen) {
+    let oauthToken;
+    try {
+      oauthToken = await getAccessToken();
+    } catch (err) {
+      logForDebugging(`[${label}:token] getAccessToken threw for sessionId=${sessionId}: ${errorMessage(err)}`, { level: "error" });
+    }
+    if (generations.get(sessionId) !== gen) {
+      logForDebugging(`[${label}:token] doRefresh for sessionId=${sessionId} stale (gen ${gen} vs ${generations.get(sessionId)}), skipping`);
+      return;
+    }
+    if (!oauthToken) {
+      const failures = (failureCounts.get(sessionId) ?? 0) + 1;
+      failureCounts.set(sessionId, failures);
+      logForDebugging(`[${label}:token] No OAuth token available for refresh, sessionId=${sessionId} (failure ${failures}/${MAX_REFRESH_FAILURES})`, { level: "error" });
+      logForDiagnosticsNoPII("error", "bridge_token_refresh_no_oauth");
+      if (failures < MAX_REFRESH_FAILURES) {
+        const retryTimer = setTimeout(doRefresh, REFRESH_RETRY_DELAY_MS, sessionId, gen);
+        timers.set(sessionId, retryTimer);
+      }
+      return;
+    }
+    failureCounts.delete(sessionId);
+    logForDebugging(`[${label}:token] Refreshing token for sessionId=${sessionId}: new token prefix=${oauthToken.slice(0, 15)}\u2026`);
+    logEvent("tengu_bridge_token_refreshed", {});
+    onRefresh(sessionId, oauthToken);
+    const timer = setTimeout(doRefresh, FALLBACK_REFRESH_INTERVAL_MS, sessionId, gen);
+    timers.set(sessionId, timer);
+    logForDebugging(`[${label}:token] Scheduled follow-up refresh for sessionId=${sessionId} in ${formatDuration(FALLBACK_REFRESH_INTERVAL_MS)}`);
+  }
+  function cancel(sessionId) {
+    nextGeneration(sessionId);
+    const timer = timers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(sessionId);
+    }
+    failureCounts.delete(sessionId);
+  }
+  function cancelAll() {
+    for (const sessionId of generations.keys()) {
+      nextGeneration(sessionId);
+    }
+    for (const timer of timers.values()) {
+      clearTimeout(timer);
+    }
+    timers.clear();
+    failureCounts.clear();
+  }
+  return { schedule, scheduleFromExpiresIn, cancel, cancelAll };
+}
 
 // src/cli/transports/ccrClient.ts
 import { randomUUID } from "crypto";
@@ -780,409 +912,4 @@ class CCRClient {
   }
 }
 
-// src/cli/transports/SSETransport.ts
-init_axios();
-init_debug();
-init_diagLogs();
-init_errors();
-init_sessionIngressAuth();
-init_sleep();
-init_slowOperations();
-init_userAgent();
-var RECONNECT_BASE_DELAY_MS = 1000;
-var RECONNECT_MAX_DELAY_MS = 30000;
-var RECONNECT_GIVE_UP_MS = 600000;
-var LIVENESS_TIMEOUT_MS = 45000;
-var PERMANENT_HTTP_CODES = new Set([401, 403, 404]);
-var POST_MAX_RETRIES = 10;
-var POST_BASE_DELAY_MS = 500;
-var POST_MAX_DELAY_MS = 8000;
-var STREAM_DECODE_OPTS = { stream: true };
-function alwaysValidStatus2() {
-  return true;
-}
-function parseSSEFrames(buffer) {
-  const frames = [];
-  let pos = 0;
-  let idx;
-  while ((idx = buffer.indexOf(`
-
-`, pos)) !== -1) {
-    const rawFrame = buffer.slice(pos, idx);
-    pos = idx + 2;
-    if (!rawFrame.trim())
-      continue;
-    const frame = {};
-    let isComment = false;
-    for (const line of rawFrame.split(`
-`)) {
-      if (line.startsWith(":")) {
-        isComment = true;
-        continue;
-      }
-      const colonIdx = line.indexOf(":");
-      if (colonIdx === -1)
-        continue;
-      const field = line.slice(0, colonIdx);
-      const value = line[colonIdx + 1] === " " ? line.slice(colonIdx + 2) : line.slice(colonIdx + 1);
-      switch (field) {
-        case "event":
-          frame.event = value;
-          break;
-        case "id":
-          frame.id = value;
-          break;
-        case "data":
-          frame.data = frame.data ? frame.data + `
-` + value : value;
-          break;
-      }
-    }
-    if (frame.data || isComment) {
-      frames.push(frame);
-    }
-  }
-  return { frames, remaining: buffer.slice(pos) };
-}
-
-class SSETransport {
-  url;
-  state = "idle";
-  onData;
-  onCloseCallback;
-  onEventCallback;
-  headers;
-  sessionId;
-  refreshHeaders;
-  getAuthHeaders;
-  abortController = null;
-  lastSequenceNum = 0;
-  seenSequenceNums = new Set;
-  reconnectAttempts = 0;
-  reconnectStartTime = null;
-  reconnectTimer = null;
-  livenessTimer = null;
-  postUrl;
-  constructor(url, headers = {}, sessionId, refreshHeaders, initialSequenceNum, getAuthHeaders) {
-    this.url = url;
-    this.headers = headers;
-    this.sessionId = sessionId;
-    this.refreshHeaders = refreshHeaders;
-    this.getAuthHeaders = getAuthHeaders ?? getSessionIngressAuthHeaders;
-    this.postUrl = convertSSEUrlToPostUrl(url);
-    if (initialSequenceNum !== undefined && initialSequenceNum > 0) {
-      this.lastSequenceNum = initialSequenceNum;
-    }
-    logForDebugging(`SSETransport: SSE URL = ${url.href}`);
-    logForDebugging(`SSETransport: POST URL = ${this.postUrl}`);
-    logForDiagnosticsNoPII("info", "cli_sse_transport_initialized");
-  }
-  getLastSequenceNum() {
-    return this.lastSequenceNum;
-  }
-  async connect() {
-    if (this.state !== "idle" && this.state !== "reconnecting") {
-      logForDebugging(`SSETransport: Cannot connect, current state is ${this.state}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_connect_failed");
-      return;
-    }
-    this.state = "reconnecting";
-    const connectStartTime = Date.now();
-    const sseUrl = new URL(this.url.href);
-    if (this.lastSequenceNum > 0) {
-      sseUrl.searchParams.set("from_sequence_num", String(this.lastSequenceNum));
-    }
-    const authHeaders = this.getAuthHeaders();
-    const headers = {
-      ...this.headers,
-      ...authHeaders,
-      Accept: "text/event-stream",
-      "anthropic-version": "2023-06-01",
-      "User-Agent": getClaudeCodeUserAgent()
-    };
-    if (authHeaders["Cookie"]) {
-      delete headers["Authorization"];
-    }
-    if (this.lastSequenceNum > 0) {
-      headers["Last-Event-ID"] = String(this.lastSequenceNum);
-    }
-    logForDebugging(`SSETransport: Opening ${sseUrl.href}`);
-    logForDiagnosticsNoPII("info", "cli_sse_connect_opening");
-    this.abortController = new AbortController;
-    try {
-      const response = await fetch(sseUrl.href, {
-        headers,
-        signal: this.abortController.signal
-      });
-      if (!response.ok) {
-        const isPermanent = PERMANENT_HTTP_CODES.has(response.status);
-        logForDebugging(`SSETransport: HTTP ${response.status}${isPermanent ? " (permanent)" : ""}`, { level: "error" });
-        logForDiagnosticsNoPII("error", "cli_sse_connect_http_error", {
-          status: response.status
-        });
-        if (isPermanent) {
-          this.state = "closed";
-          this.onCloseCallback?.(response.status);
-          return;
-        }
-        this.handleConnectionError();
-        return;
-      }
-      if (!response.body) {
-        logForDebugging("SSETransport: No response body");
-        this.handleConnectionError();
-        return;
-      }
-      const connectDuration = Date.now() - connectStartTime;
-      logForDebugging("SSETransport: Connected");
-      logForDiagnosticsNoPII("info", "cli_sse_connect_connected", {
-        duration_ms: connectDuration
-      });
-      this.state = "connected";
-      this.reconnectAttempts = 0;
-      this.reconnectStartTime = null;
-      this.resetLivenessTimer();
-      await this.readStream(response.body);
-    } catch (error) {
-      if (this.abortController?.signal.aborted) {
-        return;
-      }
-      logForDebugging(`SSETransport: Connection error: ${errorMessage(error)}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_connect_error");
-      this.handleConnectionError();
-    }
-  }
-  async readStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder;
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        buffer += decoder.decode(value, STREAM_DECODE_OPTS);
-        const { frames, remaining } = parseSSEFrames(buffer);
-        buffer = remaining;
-        for (const frame of frames) {
-          this.resetLivenessTimer();
-          if (frame.id) {
-            const seqNum = parseInt(frame.id, 10);
-            if (!isNaN(seqNum)) {
-              if (this.seenSequenceNums.has(seqNum)) {
-                logForDebugging(`SSETransport: DUPLICATE frame seq=${seqNum} (lastSequenceNum=${this.lastSequenceNum}, seenCount=${this.seenSequenceNums.size})`, { level: "warn" });
-                logForDiagnosticsNoPII("warn", "cli_sse_duplicate_sequence");
-              } else {
-                this.seenSequenceNums.add(seqNum);
-                if (this.seenSequenceNums.size > 1000) {
-                  const threshold = this.lastSequenceNum - 200;
-                  for (const s of this.seenSequenceNums) {
-                    if (s < threshold) {
-                      this.seenSequenceNums.delete(s);
-                    }
-                  }
-                }
-              }
-              if (seqNum > this.lastSequenceNum) {
-                this.lastSequenceNum = seqNum;
-              }
-            }
-          }
-          if (frame.event && frame.data) {
-            this.handleSSEFrame(frame.event, frame.data);
-          } else if (frame.data) {
-            logForDebugging("SSETransport: Frame has data: but no event: field \u2014 dropped", { level: "warn" });
-            logForDiagnosticsNoPII("warn", "cli_sse_frame_missing_event_field");
-          }
-        }
-      }
-    } catch (error) {
-      if (this.abortController?.signal.aborted)
-        return;
-      logForDebugging(`SSETransport: Stream read error: ${errorMessage(error)}`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_stream_read_error");
-    } finally {
-      reader.releaseLock();
-    }
-    if (this.state !== "closing" && this.state !== "closed") {
-      logForDebugging("SSETransport: Stream ended, reconnecting");
-      this.handleConnectionError();
-    }
-  }
-  handleSSEFrame(eventType, data) {
-    if (eventType !== "client_event") {
-      logForDebugging(`SSETransport: Unexpected SSE event type '${eventType}' on worker stream`, { level: "warn" });
-      logForDiagnosticsNoPII("warn", "cli_sse_unexpected_event_type", {
-        event_type: eventType
-      });
-      return;
-    }
-    let ev;
-    try {
-      ev = jsonParse(data);
-    } catch (error) {
-      logForDebugging(`SSETransport: Failed to parse client_event data: ${errorMessage(error)}`, { level: "error" });
-      return;
-    }
-    const payload = ev.payload;
-    if (payload && typeof payload === "object" && "type" in payload) {
-      const sessionLabel = this.sessionId ? ` session=${this.sessionId}` : "";
-      logForDebugging(`SSETransport: Event seq=${ev.sequence_num} event_id=${ev.event_id} event_type=${ev.event_type} payload_type=${String(payload.type)}${sessionLabel}`);
-      logForDiagnosticsNoPII("info", "cli_sse_message_received");
-      this.onData?.(jsonStringify(payload) + `
-`);
-    } else {
-      logForDebugging(`SSETransport: Ignoring client_event with no type in payload: event_id=${ev.event_id}`);
-    }
-    this.onEventCallback?.(ev);
-  }
-  handleConnectionError() {
-    this.clearLivenessTimer();
-    if (this.state === "closing" || this.state === "closed")
-      return;
-    this.abortController?.abort();
-    this.abortController = null;
-    const now = Date.now();
-    if (!this.reconnectStartTime) {
-      this.reconnectStartTime = now;
-    }
-    const elapsed = now - this.reconnectStartTime;
-    if (elapsed < RECONNECT_GIVE_UP_MS) {
-      if (this.reconnectTimer) {
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = null;
-      }
-      if (this.refreshHeaders) {
-        const freshHeaders = this.refreshHeaders();
-        Object.assign(this.headers, freshHeaders);
-        logForDebugging("SSETransport: Refreshed headers for reconnect");
-      }
-      this.state = "reconnecting";
-      this.reconnectAttempts++;
-      const baseDelay = Math.min(RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts - 1), RECONNECT_MAX_DELAY_MS);
-      const delay = Math.max(0, baseDelay + baseDelay * 0.25 * (2 * Math.random() - 1));
-      logForDebugging(`SSETransport: Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}, ${Math.round(elapsed / 1000)}s elapsed)`);
-      logForDiagnosticsNoPII("error", "cli_sse_reconnect_attempt", {
-        reconnectAttempts: this.reconnectAttempts
-      });
-      this.reconnectTimer = setTimeout(() => {
-        this.reconnectTimer = null;
-        this.connect();
-      }, delay);
-    } else {
-      logForDebugging(`SSETransport: Reconnection time budget exhausted after ${Math.round(elapsed / 1000)}s`, { level: "error" });
-      logForDiagnosticsNoPII("error", "cli_sse_reconnect_exhausted", {
-        reconnectAttempts: this.reconnectAttempts,
-        elapsedMs: elapsed
-      });
-      this.state = "closed";
-      this.onCloseCallback?.();
-    }
-  }
-  onLivenessTimeout = () => {
-    this.livenessTimer = null;
-    logForDebugging("SSETransport: Liveness timeout, reconnecting", {
-      level: "error"
-    });
-    logForDiagnosticsNoPII("error", "cli_sse_liveness_timeout");
-    this.abortController?.abort();
-    this.handleConnectionError();
-  };
-  resetLivenessTimer() {
-    this.clearLivenessTimer();
-    this.livenessTimer = setTimeout(this.onLivenessTimeout, LIVENESS_TIMEOUT_MS);
-  }
-  clearLivenessTimer() {
-    if (this.livenessTimer) {
-      clearTimeout(this.livenessTimer);
-      this.livenessTimer = null;
-    }
-  }
-  async write(message) {
-    const authHeaders = this.getAuthHeaders();
-    if (Object.keys(authHeaders).length === 0) {
-      logForDebugging("SSETransport: No session token available for POST");
-      logForDiagnosticsNoPII("warn", "cli_sse_post_no_token");
-      return;
-    }
-    const headers = {
-      ...authHeaders,
-      "Content-Type": "application/json",
-      "anthropic-version": "2023-06-01",
-      "User-Agent": getClaudeCodeUserAgent()
-    };
-    logForDebugging(`SSETransport: POST body keys=${Object.keys(message).join(",")}`);
-    for (let attempt = 1;attempt <= POST_MAX_RETRIES; attempt++) {
-      try {
-        const response = await axios_default.post(this.postUrl, message, {
-          headers,
-          validateStatus: alwaysValidStatus2
-        });
-        if (response.status === 200 || response.status === 201) {
-          logForDebugging(`SSETransport: POST success type=${message.type}`);
-          return;
-        }
-        logForDebugging(`SSETransport: POST ${response.status} body=${jsonStringify(response.data).slice(0, 200)}`);
-        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-          logForDebugging(`SSETransport: POST returned ${response.status} (client error), not retrying`);
-          logForDiagnosticsNoPII("warn", "cli_sse_post_client_error", {
-            status: response.status
-          });
-          return;
-        }
-        logForDebugging(`SSETransport: POST returned ${response.status}, attempt ${attempt}/${POST_MAX_RETRIES}`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_retryable_error", {
-          status: response.status,
-          attempt
-        });
-      } catch (error) {
-        const axiosError = error;
-        logForDebugging(`SSETransport: POST error: ${axiosError.message}, attempt ${attempt}/${POST_MAX_RETRIES}`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_network_error", {
-          attempt
-        });
-      }
-      if (attempt === POST_MAX_RETRIES) {
-        logForDebugging(`SSETransport: POST failed after ${POST_MAX_RETRIES} attempts, continuing`);
-        logForDiagnosticsNoPII("warn", "cli_sse_post_retries_exhausted");
-        return;
-      }
-      const delayMs = Math.min(POST_BASE_DELAY_MS * Math.pow(2, attempt - 1), POST_MAX_DELAY_MS);
-      await sleep(delayMs);
-    }
-  }
-  isConnectedStatus() {
-    return this.state === "connected";
-  }
-  isClosedStatus() {
-    return this.state === "closed";
-  }
-  setOnData(callback) {
-    this.onData = callback;
-  }
-  setOnClose(callback) {
-    this.onCloseCallback = callback;
-  }
-  setOnEvent(callback) {
-    this.onEventCallback = callback;
-  }
-  close() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.clearLivenessTimer();
-    this.state = "closing";
-    this.abortController?.abort();
-    this.abortController = null;
-  }
-}
-function convertSSEUrlToPostUrl(sseUrl) {
-  let pathname = sseUrl.pathname;
-  if (pathname.endsWith("/stream")) {
-    pathname = pathname.slice(0, -"/stream".length);
-  }
-  return `${sseUrl.protocol}//${sseUrl.host}${pathname}`;
-}
-
-export { SerialBatchEventUploader, CCRInitError, CCRClient, SSETransport };
+export { createTokenRefreshScheduler, SerialBatchEventUploader, CCRInitError, CCRClient };

package/dist/chunk-8az1n4zt.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  Doctor,
+  init_Doctor
+} from "./chunk-5bta6qne.js";
+import"./chunk-zq6tz1zv.js";
+import"./chunk-qhwvhgty.js";
+import"./chunk-30bpz5m2.js";
+import"./chunk-66hjztcb.js";
+import"./chunk-13f30tg0.js";
+import"./chunk-p8enbwjk.js";
+import"./chunk-4m6k7588.js";
+import"./chunk-nea2sah6.js";
+import"./chunk-rs8304k5.js";
+import"./chunk-1c2qp0ks.js";
+import"./chunk-9z4vq44b.js";
+import"./chunk-zejm280k.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-akxywws0.js";
+import"./chunk-zf47p99b.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-1xbs4yb6.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-8h6sdj66.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-6eg4c33n.js";
+import"./chunk-2cctz9ww.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-d0n93ge4.js";
+import"./chunk-5pevjsyw.js";
+import"./chunk-xnav6j8h.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-2t0xa4dt.js";
+import"./chunk-pwr83fyy.js";
+import"./chunk-hjnbg9qw.js";
+import"./chunk-zsgha506.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-xkt36p6r.js";
+import"./chunk-585cb3h6.js";
+import"./chunk-xk9pxqqx.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-bx811wk6.js";
+import"./chunk-8vnxjgz9.js";
+import"./chunk-2v8cya3p.js";
+import"./chunk-eyqnj23w.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-6mpw9h55.js";
+import"./chunk-zhtrjznv.js";
+import"./chunk-sg66v252.js";
+import"./chunk-8bwqtasa.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-cztjpxq4.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-gx8016vp.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-r7j395t6.js";
+import"./chunk-tv9pcdnz.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-n9ktjngj.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-64hks9ax.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-cmsknj6n.js";
+import"./chunk-g338npwr.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-h1mr3371.js";
+import"./chunk-36b2q5fg.js";
+import"./chunk-a7rhvq9b.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-m74w3187.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-y3r7v9pq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-awb4vc41.js";
+import"./chunk-cbrt5vsb.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-404qm8xt.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.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"./chunk-qp2qdcda.js";
+init_Doctor();
+
+export {
+  Doctor
+};