@letrquan/book 0.3.0 → 0.4.0-beta.0

package/dist/chunk-ECLC4CIJ.js

@@ -0,0 +1,1181 @@
+import {
+  settingsScopePath
+} from "./chunk-FPR7SKIE.js";
+import {
+  redactSecrets,
+  resolveSecret
+} from "./chunk-N2G4Q7ME.js";
+import {
+  isRedirectResponse,
+  refuseRedirect
+} from "./chunk-AHC7OU75.js";
+import {
+  parseEnvBoolean
+} from "./chunk-UCFJ43OS.js";
+import {
+  systemClock
+} from "./chunk-RT5SATF7.js";
+import {
+  PROVIDER_CONNECTION_KEYS,
+  parseSecretReference
+} from "./chunk-B5FC3MYZ.js";
+import {
+  SettingsRepository,
+  deleteNestedValue,
+  formatSettingsDiagnostics,
+  providerConfigSchema,
+  readSettingsDocument
+} from "./chunk-REASC2QG.js";
+import {
+  projectFileWriteRefusal
+} from "./chunk-IDYWN37T.js";
+
+// src/provider/model-discovery.ts
+var DEFAULT_PROVIDER_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  anthropic: "https://api.anthropic.com"
+};
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429, 529]);
+var MAX_ANTHROPIC_PAGES = 100;
+var ModelDiscoveryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ModelDiscoveryError";
+  }
+  code;
+};
+function normalizeProviderBaseUrl(_type, raw) {
+  const trimmed = raw.trim();
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    throw new ModelDiscoveryError("Enter a valid HTTP(S) base URL.", "request");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new ModelDiscoveryError("Base URL must use HTTP or HTTPS.", "request");
+  }
+  if (url.username || url.password) {
+    throw new ModelDiscoveryError("Base URL cannot contain embedded credentials.", "request");
+  }
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+  return url.toString().replace(/\/$/, "");
+}
+function discoveryUrl(type, baseUrl, afterId) {
+  const base = normalizeProviderBaseUrl(type, baseUrl);
+  if (type === "openai") return `${base}/models`;
+  const url = new URL(`${base}${/\/v1$/i.test(new URL(base).pathname) ? "" : "/v1"}/models`);
+  url.searchParams.set("limit", "100");
+  if (afterId) url.searchParams.set("after_id", afterId);
+  return url.toString();
+}
+function safeStatusError(status) {
+  if (status === 401 || status === 403) {
+    return new ModelDiscoveryError(
+      "Model discovery was not authorized. Check the API key and endpoint permissions.",
+      "auth"
+    );
+  }
+  if (status === 404 || status === 405 || status === 501) {
+    return new ModelDiscoveryError(
+      "This endpoint does not expose a supported model-list API.",
+      "unsupported"
+    );
+  }
+  return new ModelDiscoveryError(`Model discovery request failed with HTTP ${status}.`, "request");
+}
+function redirectMessage({ status, target }) {
+  const http = status === 0 ? "" : ` (HTTP ${status})`;
+  const what = target === void 0 ? `answered${status === 0 ? "" : ` HTTP ${status}`} with no redirect target Book could read` : `redirected to ${target}${http}`;
+  return `The model-list endpoint ${what}; Book does not follow provider redirects. Check the provider's base URL.`;
+}
+function retryDelay(attempt, retry, retryAfter) {
+  const retryAfterSeconds = retryAfter === null ? NaN : Number(retryAfter);
+  if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0) {
+    return Math.min(retryAfterSeconds * 1e3, retry.maxDelayMs);
+  }
+  return Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
+}
+function wait(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new ModelDiscoveryError("Model discovery was cancelled.", "aborted"));
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new ModelDiscoveryError("Model discovery was cancelled.", "aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function fetchWithRetry(url, init, options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const clock = options.clock ?? systemClock;
+  const startedAt = clock.monotonicNowMs();
+  let lastNetworkError;
+  for (let attempt = 0; attempt <= options.retry.maxAttempts; attempt++) {
+    if (options.signal?.aborted) {
+      throw new ModelDiscoveryError("Model discovery was cancelled.", "aborted");
+    }
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timeout = setTimeout(
+      () => controller.abort(new Error("request timeout")),
+      options.retry.requestTimeoutMs
+    );
+    let response;
+    try {
+      response = await fetchImpl(url, { ...init, redirect: "manual", signal: controller.signal });
+    } catch (error) {
+      if (options.signal?.aborted) {
+        throw new ModelDiscoveryError("Model discovery was cancelled.", "aborted");
+      }
+      lastNetworkError = error;
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", abortFromCaller);
+    }
+    if (response && isRedirectResponse(response)) {
+      const refused = await refuseRedirect(response, url);
+      throw new ModelDiscoveryError(redirectMessage(refused), "request");
+    }
+    if (response && !(RETRYABLE_STATUSES.has(response.status) || response.status >= 500)) {
+      return response;
+    }
+    if (attempt >= options.retry.maxAttempts) {
+      if (response) return response;
+      throw new ModelDiscoveryError("Could not reach the model-list endpoint.", "network");
+    }
+    if (options.retry.totalBudgetMs > 0 && clock.monotonicNowMs() - startedAt >= options.retry.totalBudgetMs) {
+      if (response) return response;
+      throw new ModelDiscoveryError("Could not reach the model-list endpoint.", "network");
+    }
+    const delay = retryDelay(attempt, options.retry, response?.headers.get("retry-after") ?? null);
+    options.onRetry?.(attempt + 1, options.retry.maxAttempts, delay);
+    await wait(delay, options.signal);
+  }
+  throw new ModelDiscoveryError(
+    lastNetworkError ? "Could not reach the model-list endpoint." : "Model discovery failed.",
+    "network"
+  );
+}
+function parseModels(payload, type) {
+  if (!payload || typeof payload !== "object") {
+    throw new ModelDiscoveryError(
+      "The model-list endpoint returned invalid JSON.",
+      "invalid_response"
+    );
+  }
+  const data = payload.data;
+  if (!Array.isArray(data)) {
+    throw new ModelDiscoveryError(
+      "The model-list endpoint returned an unsupported response shape.",
+      "invalid_response"
+    );
+  }
+  const models = [];
+  for (const item of data) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    if (!id || /[\x00-\x1f\x7f]/.test(id)) continue;
+    const rawLabel = type === "anthropic" ? record.display_name : record.name ?? record.display_name ?? record.label;
+    const label = typeof rawLabel === "string" && rawLabel.trim() ? rawLabel.trim() : void 0;
+    const model = { id, label };
+    const limit = record.max_input_tokens;
+    if (type === "anthropic" && typeof limit === "number" && Number.isSafeInteger(limit) && limit > 0) {
+      model.reportedContextWindow = limit;
+    }
+    models.push(model);
+  }
+  return models;
+}
+async function discoverModels(options) {
+  const headers = options.type === "anthropic" ? {
+    "x-api-key": options.apiKey,
+    "anthropic-version": "2023-06-01"
+  } : { Authorization: `Bearer ${options.apiKey}` };
+  const discovered = [];
+  let afterId;
+  let finished = false;
+  for (let page = 0; page < MAX_ANTHROPIC_PAGES; page++) {
+    const response = await fetchWithRetry(
+      discoveryUrl(options.type, options.baseUrl, afterId),
+      { method: "GET", headers },
+      options
+    );
+    if (!response.ok) throw safeStatusError(response.status);
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new ModelDiscoveryError(
+        "The model-list endpoint returned invalid JSON.",
+        "invalid_response"
+      );
+    }
+    discovered.push(...parseModels(payload, options.type));
+    if (options.type !== "anthropic") {
+      finished = true;
+      break;
+    }
+    const pageInfo = payload;
+    if (pageInfo.has_more !== true) {
+      finished = true;
+      break;
+    }
+    const nextId = typeof pageInfo.last_id === "string" ? pageInfo.last_id : void 0;
+    if (!nextId || nextId === afterId) {
+      throw new ModelDiscoveryError(
+        "The model-list endpoint returned invalid pagination metadata.",
+        "invalid_response"
+      );
+    }
+    afterId = nextId;
+  }
+  if (options.type === "anthropic" && !finished) {
+    throw new ModelDiscoveryError(
+      "The model-list endpoint exceeded the pagination limit.",
+      "invalid_response"
+    );
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const model of discovered) {
+    const existing = deduped.get(model.id);
+    if (!existing) {
+      deduped.set(model.id, model);
+      continue;
+    }
+    const label = existing.label || model.label;
+    const reportedContextWindow = existing.reportedContextWindow ?? model.reportedContextWindow;
+    const merged = { id: model.id, label };
+    if (reportedContextWindow !== void 0) merged.reportedContextWindow = reportedContextWindow;
+    deduped.set(model.id, merged);
+  }
+  const models = [...deduped.values()].sort((a, b) => a.id.localeCompare(b.id));
+  if (models.length === 0) {
+    throw new ModelDiscoveryError(
+      "The endpoint did not return any usable models.",
+      "invalid_response"
+    );
+  }
+  return models;
+}
+
+// src/provider-key.ts
+import { existsSync } from "fs";
+function validateApiKey(raw) {
+  if (!raw.trim()) throw new Error("API key is required.");
+  if (/[\r\n\x00]/.test(raw)) throw new Error("API key cannot contain line breaks.");
+  return raw;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function providerEntryOf(document, providerId) {
+  const registry = document.provider;
+  if (!isPlainObject(registry) || !Object.hasOwn(registry, providerId)) return void 0;
+  const entry = registry[providerId];
+  return isPlainObject(entry) ? entry : void 0;
+}
+function providerKeyTarget(workspace, providerId) {
+  const path = settingsScopePath("user", workspace);
+  const user = readSettingsDocument(path);
+  if (user.status === "malformed" || user.status === "non-object") {
+    return { kind: "unreadable", providerId, path, error: user.error };
+  }
+  const document = user.status === "valid" ? user.document : {};
+  if (isPlainObject(document.provider) && Object.hasOwn(document.provider, providerId)) {
+    const entry = document.provider[providerId];
+    const parsed = providerConfigSchema.safeParse(
+      isPlainObject(entry) ? { ...entry, apiKey: void 0 } : entry
+    );
+    if (!parsed.success) {
+      return {
+        kind: "unreadable",
+        providerId,
+        path,
+        error: `Provider "${providerId}" is not a valid provider entry: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "(entry)"}: ${issue.message}`).join("; ")}`
+      };
+    }
+    return { kind: "owned", providerId, path, provider: parsed.data };
+  }
+  for (const scope of ["project", "local"]) {
+    const workspacePath = settingsScopePath(scope, workspace);
+    const layer = readSettingsDocument(workspacePath);
+    if (layer.status === "valid" && providerEntryOf(layer.document, providerId)) {
+      return { kind: "workspace-only", providerId, path, declaredIn: workspacePath };
+    }
+  }
+  const configured = isPlainObject(document.provider) ? Object.keys(document.provider).sort() : [];
+  return { kind: "unknown", providerId, path, configured };
+}
+function deleteProviderConnectionKeys(document, providerId) {
+  for (const key of PROVIDER_CONNECTION_KEYS) {
+    deleteNestedValue(document, ["provider", providerId, key]);
+  }
+}
+function writeProviderKey(workspace, providerId, apiKey) {
+  const path = settingsScopePath("user", workspace);
+  const localPath = settingsScopePath("local", workspace);
+  const localRefusal = projectFileWriteRefusal(localPath);
+  if (localRefusal) return { ok: false, error: `${localPath}: ${localRefusal}` };
+  const written = new SettingsRepository(path).update((candidate) => {
+    const entry = providerEntryOf(candidate, providerId);
+    if (!entry) throw new Error(`Provider "${providerId}" is not configured in ${path}.`);
+    entry.apiKey = apiKey;
+  });
+  if (!written.ok) {
+    return {
+      ok: false,
+      error: redactSecrets(formatSettingsDiagnostics(written.diagnostics), [apiKey])
+    };
+  }
+  if (!existsSync(localPath)) return { ok: true, path };
+  const local = readSettingsDocument(localPath);
+  const localEntry = local.status === "valid" ? providerEntryOf(local.document, providerId) : null;
+  if (!localEntry || !PROVIDER_CONNECTION_KEYS.some((key) => localEntry[key] !== void 0)) {
+    return { ok: true, path };
+  }
+  const cleared = new SettingsRepository(localPath).update(
+    (candidate) => deleteProviderConnectionKeys(candidate, providerId)
+  );
+  return cleared.ok ? { ok: true, path, localCleared: localPath } : {
+    ok: true,
+    path,
+    localError: redactSecrets(formatSettingsDiagnostics(cleared.diagnostics), [apiKey])
+  };
+}
+var CHECK_RETRIES = 0;
+var CHECK_REQUEST_TIMEOUT_MS = 2e4;
+async function checkProviderKey(options) {
+  const baseUrl = options.provider.baseURL ?? options.provider.baseUrl;
+  if (!baseUrl) {
+    return {
+      ok: false,
+      error: "This provider has no base URL configured, so the key cannot be tested."
+    };
+  }
+  const resolved = resolveSecret(options.apiKey, options.workspace);
+  if (!resolved) {
+    const reference = parseSecretReference(options.apiKey);
+    return {
+      ok: false,
+      error: reference.kind === "env" ? `Environment variable ${reference.name} is not set.` : reference.kind === "file" ? `Could not read a key from ${reference.path}.` : "API key is required."
+    };
+  }
+  const discover = options.discover ?? discoverModels;
+  try {
+    const models = await discover({
+      type: options.provider.type,
+      baseUrl,
+      apiKey: resolved,
+      retry: {
+        ...options.retry,
+        maxAttempts: Math.min(options.retry.maxAttempts, CHECK_RETRIES),
+        requestTimeoutMs: Math.min(options.retry.requestTimeoutMs, CHECK_REQUEST_TIMEOUT_MS)
+      },
+      signal: options.signal
+    });
+    if (models.length === 0) {
+      return { ok: false, error: "The endpoint did not return any models." };
+    }
+    return { ok: true, modelCount: models.length };
+  } catch (caught) {
+    const message = caught instanceof Error ? caught.message : "The key check failed.";
+    return { ok: false, error: redactSecrets(message, [options.apiKey, resolved]) };
+  }
+}
+
+// src/cli/ink-renderer.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+var INK_TRAILING_NEWLINE_FIX = "ansiEscapes.cursorUp(previousLines.length - 1)";
+function inkBuildDir(from = import.meta.url) {
+  const require2 = createRequire(from);
+  return dirname(require2.resolve("ink"));
+}
+function inkLogUpdatePath(from) {
+  return join(inkBuildDir(from), "log-update.js");
+}
+function hasInkTrailingNewlineFix(from) {
+  try {
+    return readFileSync(inkLogUpdatePath(from), "utf8").includes(INK_TRAILING_NEWLINE_FIX);
+  } catch {
+    return false;
+  }
+}
+async function loadInkFlushSync(from) {
+  try {
+    const module = await import(pathToFileURL(join(inkBuildDir(from), "reconciler.js")).href);
+    const reconciler = module.default;
+    const flush = reconciler?.flushSyncFromReconciler;
+    if (typeof flush !== "function") return void 0;
+    return (update) => {
+      flush.call(reconciler, update);
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function wrapInkLogUpdate(wrap) {
+  try {
+    const module = await import(pathToFileURL(inkLogUpdatePath()).href);
+    const logUpdate = module.default;
+    logUpdate.create = wrap(logUpdate.create);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/ink-scroll-renderer.ts
+var pendingHint = null;
+var rendererInstalled = false;
+function isInkScrollRendererEnabled(value) {
+  return value === "on";
+}
+function setTranscriptScrollHint(hint) {
+  if (!Number.isFinite(hint.delta) || hint.delta === 0) return;
+  if (pendingHint && pendingHint.top === hint.top && pendingHint.bottom === hint.bottom && Math.sign(pendingHint.delta) === Math.sign(hint.delta)) {
+    pendingHint = { ...pendingHint, delta: pendingHint.delta + hint.delta };
+    return;
+  }
+  pendingHint = { ...hint };
+}
+function splitFrame(frame) {
+  return frame.endsWith("\n") ? frame.slice(0, -1).split("\n") : frame.split("\n");
+}
+function getFrameEndRow(frame, visibleLineCount) {
+  return visibleLineCount + (frame.endsWith("\n") ? 1 : 0);
+}
+function cursorTo(row) {
+  return `\x1B[${Math.max(1, Math.floor(row))};1H`;
+}
+function setScrollRegion(top, bottom) {
+  return `\x1B[${Math.max(1, Math.floor(top))};${Math.max(1, Math.floor(bottom))}r`;
+}
+function isPureVerticalShift(previousLines, nextLines, hint) {
+  if (previousLines.length !== nextLines.length) return false;
+  const top = Math.floor(hint.top) - 1;
+  const bottom = Math.floor(hint.bottom);
+  const delta = Math.trunc(hint.delta);
+  if (top < 0 || bottom > nextLines.length || bottom - top < 2) return false;
+  if (Math.abs(delta) >= bottom - top) return false;
+  for (let row = 0; row < top; row++) {
+    if (previousLines[row] !== nextLines[row]) return false;
+  }
+  for (let row = bottom; row < nextLines.length; row++) {
+    if (previousLines[row] !== nextLines[row]) return false;
+  }
+  if (delta > 0) {
+    for (let row = top; row < bottom - delta; row++) {
+      if (nextLines[row] !== previousLines[row + delta]) return false;
+    }
+  } else {
+    const distance = Math.abs(delta);
+    for (let row = top + distance; row < bottom; row++) {
+      if (nextLines[row] !== previousLines[row - distance]) return false;
+    }
+  }
+  return true;
+}
+function writeExposedRows(stream, lines, top, bottom, delta) {
+  const distance = Math.abs(delta);
+  const first = delta > 0 ? bottom - distance : top;
+  for (let offset = 0; offset < distance; offset++) {
+    const row = first + offset;
+    stream.write(cursorTo(row + 1) + (lines[row] ?? "") + "\x1B[K");
+  }
+}
+function createScrollAwareRenderer(stream, options, createBase) {
+  const base = createBase(stream, options);
+  let previousFrame = "";
+  const render = ((output) => {
+    const hint = pendingHint;
+    pendingHint = null;
+    const previousLines = splitFrame(previousFrame);
+    const nextLines = splitFrame(output);
+    const terminalRows = stream.rows ?? 0;
+    const frameEndRow = getFrameEndRow(output, nextLines.length);
+    const canScroll = Boolean(stream.isTTY) && terminalRows > 0 && frameEndRow <= terminalRows && previousFrame.length > 0 && hint !== null && hint.bottom <= nextLines.length && isPureVerticalShift(previousLines, nextLines, hint);
+    if (canScroll && hint) {
+      const top = Math.floor(hint.top);
+      const bottom = Math.floor(hint.bottom);
+      const delta = Math.trunc(hint.delta);
+      stream.write("\x1B[?25l" + setScrollRegion(top, bottom));
+      stream.write(`\x1B[${Math.abs(delta)}${delta > 0 ? "S" : "T"}`);
+      writeExposedRows(stream, nextLines, top - 1, bottom, delta);
+      stream.write(setScrollRegion(1, terminalRows) + cursorTo(frameEndRow));
+      previousFrame = output;
+      base.sync(output);
+      return true;
+    }
+    previousFrame = output;
+    return base(output);
+  });
+  render.clear = () => {
+    pendingHint = null;
+    previousFrame = "";
+    base.clear();
+  };
+  render.done = () => {
+    pendingHint = null;
+    previousFrame = "";
+    base.done();
+  };
+  render.reset = () => {
+    pendingHint = null;
+    previousFrame = "";
+    base.reset?.();
+  };
+  render.sync = (output) => {
+    pendingHint = null;
+    previousFrame = output;
+    base.sync(output);
+  };
+  render.setCursorPosition = (position) => base.setCursorPosition(position);
+  render.isCursorDirty = () => base.isCursorDirty();
+  render.willRender = (output) => {
+    const shouldRender = base.willRender(output);
+    if (!shouldRender) pendingHint = null;
+    return shouldRender;
+  };
+  return render;
+}
+async function installInkScrollRenderer(enabled) {
+  if (rendererInstalled) return;
+  if (!(enabled ?? isInkScrollRendererEnabled(process.env.BOOK_SCROLL_RENDERER))) return;
+  rendererInstalled = true;
+  await wrapInkLogUpdate(
+    (createBase) => (stream, options) => createScrollAwareRenderer(stream, options, createBase)
+  );
+}
+
+// src/cli/frame-buffer.ts
+var latestFrame = "";
+var lastCursorPosition = null;
+var captureInstalled = false;
+var frameUpdateListeners = /* @__PURE__ */ new Set();
+function notifyFrameUpdate() {
+  for (const listener of frameUpdateListeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function splitFrame2(frame) {
+  return frame.endsWith("\n") ? frame.slice(0, -1).split("\n") : frame.split("\n");
+}
+function toCursorPosition(position) {
+  if (!position || typeof position !== "object") return null;
+  const candidate = position;
+  if (typeof candidate.x !== "number" || typeof candidate.y !== "number") return null;
+  return { x: candidate.x, y: candidate.y };
+}
+function getFrameLines() {
+  return latestFrame.length === 0 ? [] : splitFrame2(latestFrame);
+}
+function getLastCursorPosition() {
+  return lastCursorPosition;
+}
+function subscribeToFrameUpdates(listener) {
+  frameUpdateListeners.add(listener);
+  return () => frameUpdateListeners.delete(listener);
+}
+function createFrameCapturingRenderer(stream, options, createBase) {
+  const base = createBase(stream, options);
+  const render = ((output) => {
+    latestFrame = output;
+    const rendered = base(output);
+    if (rendered !== false) notifyFrameUpdate();
+    return rendered;
+  });
+  render.clear = () => {
+    latestFrame = "";
+    base.clear();
+  };
+  render.done = () => {
+    latestFrame = "";
+    lastCursorPosition = null;
+    base.done();
+  };
+  render.reset = () => {
+    latestFrame = "";
+    base.reset?.();
+  };
+  render.sync = (output) => {
+    latestFrame = output;
+    base.sync(output);
+    notifyFrameUpdate();
+  };
+  render.setCursorPosition = (position) => {
+    lastCursorPosition = toCursorPosition(position);
+    base.setCursorPosition(position);
+  };
+  render.isCursorDirty = () => base.isCursorDirty();
+  render.willRender = (output) => base.willRender(output);
+  return render;
+}
+async function installFrameCapture() {
+  if (captureInstalled) return;
+  captureInstalled = true;
+  await wrapInkLogUpdate(
+    (createBase) => (stream, options) => createFrameCapturingRenderer(stream, options, createBase)
+  );
+}
+
+// src/cli/ink-output-cache.ts
+import { createRequire as createRequire2 } from "module";
+import { join as join2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var DEFAULT_LIMITS = {
+  styledChars: 1024,
+  widths: 8192,
+  blockWidths: 1024,
+  sliceCache: 2048,
+  rowCache: 2048
+};
+function evictOldest(cache) {
+  const oldest = cache.keys().next().value;
+  if (oldest !== void 0) cache.delete(oldest);
+}
+function refresh(cache, key) {
+  const value = cache.get(key);
+  if (value === void 0) return void 0;
+  cache.delete(key);
+  cache.set(key, value);
+  return value;
+}
+function remember(cache, key, value, limit) {
+  if (cache.size >= limit) evictOldest(cache);
+  cache.set(key, value);
+}
+function trim(cache, limit) {
+  while (cache.size > limit) evictOldest(cache);
+}
+function createRowCachedGet(options) {
+  const { originalGet, sliceAnsi, Output } = options;
+  const limits = { ...DEFAULT_LIMITS, ...options.limits };
+  const rowCache = /* @__PURE__ */ new Map();
+  const sliceCache = /* @__PURE__ */ new Map();
+  const counters = { frames: 0, rows: 0, rowHits: 0, fallbacks: 0 };
+  let sharedCaches = null;
+  const get = function() {
+    if (sharedCaches === null) sharedCaches = this.caches;
+    const caches = sharedCaches;
+    this.caches = caches;
+    trim(caches.styledChars, limits.styledChars);
+    trim(caches.widths, limits.widths);
+    trim(caches.blockWidths, limits.blockWidths);
+    const rows = [];
+    for (let y = 0; y < this.height; y++) rows.push([]);
+    const clips = [];
+    for (const operation of this.operations) {
+      if (operation.type === "clip") clips.push(operation.clip);
+      if (operation.type === "unclip") clips.pop();
+      if (operation.type !== "write") continue;
+      const { text, transformers } = operation;
+      let { x, y } = operation;
+      let lines = text.split("\n");
+      const clip = clips.at(-1);
+      if (clip) {
+        const { x1, x2, y1, y2 } = clip;
+        const clipHorizontally = typeof x1 === "number" && typeof x2 === "number";
+        const clipVertically = typeof y1 === "number" && typeof y2 === "number";
+        if (clipHorizontally) {
+          if (x + caches.getWidestLine(text) < x1 || x > x2) continue;
+        }
+        if (clipVertically) {
+          if (y + lines.length < y1 || y > y2) continue;
+        }
+        if (clipHorizontally) {
+          lines = lines.map((line) => {
+            const from = x < x1 ? x1 - x : 0;
+            const width = caches.getStringWidth(line);
+            const to = x + width > x2 ? x2 - x : width;
+            const key = `${from},${to},${line.length},${line}`;
+            const cached = refresh(sliceCache, key);
+            if (cached !== void 0) return cached;
+            const sliced = sliceAnsi(line, from, to);
+            remember(sliceCache, key, sliced, limits.sliceCache);
+            return sliced;
+          });
+          if (x < x1) x = x1;
+        }
+        if (clipVertically) {
+          const from = y < y1 ? y1 - y : 0;
+          const to = y + lines.length > y2 ? y2 - y : lines.length;
+          lines = lines.slice(from, to);
+          if (y < y1) y = y1;
+        }
+      }
+      let offsetY = 0;
+      for (const [index, original] of lines.entries()) {
+        if (!rows[y + offsetY]) continue;
+        let line = original;
+        for (const transformer of transformers) line = transformer(line, index);
+        if (line.includes("\n")) {
+          counters.fallbacks++;
+          counters.frames++;
+          return originalGet.call(this);
+        }
+        rows[y + offsetY].push([x, line]);
+        offsetY++;
+      }
+    }
+    const frame = new Array(rows.length);
+    const misses = [];
+    const missKeys = [];
+    for (let row = 0; row < rows.length; row++) {
+      const fragments = rows[row];
+      counters.rows++;
+      if (fragments.length === 0) {
+        frame[row] = "";
+        counters.rowHits++;
+        continue;
+      }
+      let key = `${this.width}|`;
+      for (const [x, line] of fragments) key += `${x},${line.length},${line}`;
+      const cached = refresh(rowCache, key);
+      if (cached === void 0) {
+        misses.push(row);
+        missKeys.push(key);
+      } else {
+        frame[row] = cached;
+        counters.rowHits++;
+      }
+    }
+    if (misses.length > 0) {
+      const scratch = new Output({ width: this.width, height: misses.length });
+      scratch.caches = caches;
+      misses.forEach((row, index) => {
+        for (const [x, line] of rows[row] ?? []) {
+          scratch.operations.push({ type: "write", x, y: index, text: line, transformers: [] });
+        }
+      });
+      const built = originalGet.call(scratch).output.split("\n");
+      misses.forEach((row, index) => {
+        const text = built[index] ?? "";
+        frame[row] = text;
+        remember(rowCache, missKeys[index], text, limits.rowCache);
+      });
+    }
+    counters.frames++;
+    return { output: frame.join("\n"), height: this.height };
+  };
+  Object.defineProperty(get, INSTALLED_MARK, { value: true });
+  return {
+    get,
+    stats: () => ({ ...counters, rowCacheSize: rowCache.size, sliceCacheSize: sliceCache.size })
+  };
+}
+function isInkOutputShape(candidate) {
+  if (typeof candidate !== "function") return false;
+  const Output = candidate;
+  const prototype = Output.prototype;
+  if (typeof prototype !== "object" || prototype === null) return false;
+  if (typeof prototype.get !== "function") return false;
+  let instance;
+  try {
+    instance = new Output({ width: 1, height: 1 });
+  } catch {
+    return false;
+  }
+  if (!Array.isArray(instance.operations)) return false;
+  const caches = instance.caches;
+  if (typeof caches !== "object" || caches === null) return false;
+  const shaped = caches;
+  return typeof shaped.getStyledChars === "function" && typeof shaped.getStringWidth === "function" && typeof shaped.getWidestLine === "function" && shaped.styledChars instanceof Map && shaped.widths instanceof Map && shaped.blockWidths instanceof Map;
+}
+var INSTALLED_MARK = /* @__PURE__ */ Symbol("book.rowCachedInkGet");
+function isRowCachedGet(candidate) {
+  if (typeof candidate !== "function") return false;
+  const prototype = candidate.prototype;
+  const get = prototype?.get;
+  return get?.[INSTALLED_MARK] === true;
+}
+async function installInkOutputCache(env = process.env) {
+  try {
+    const outputPath = join2(inkBuildDir(), "output.js");
+    const outputModule = await import(pathToFileURL2(outputPath).href);
+    if (isRowCachedGet(outputModule.default)) return true;
+    if (parseEnvBoolean(env.BOOK_INK_OUTPUT_CACHE) === false) return false;
+    const sliceAnsiPath = createRequire2(outputPath).resolve("slice-ansi");
+    const sliceAnsi = (await import(pathToFileURL2(sliceAnsiPath).href)).default;
+    const Output = outputModule.default;
+    if (!isInkOutputShape(Output) || typeof sliceAnsi !== "function") return false;
+    const originalGet = Output.prototype.get;
+    Output.prototype.get = createRowCachedGet({
+      originalGet,
+      sliceAnsi,
+      Output
+    }).get;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/ink-render-cull.ts
+import { createRequire as createRequire3 } from "module";
+import { join as join3 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+var INSTALLED_MARK2 = /* @__PURE__ */ Symbol("book.inkRenderCull");
+var REAL_DISPLAY = /* @__PURE__ */ Symbol("book.inkRenderCullRealDisplay");
+function isCullableYogaNode(candidate) {
+  if (typeof candidate !== "object" || candidate === null) return false;
+  const node = candidate;
+  return typeof node.getDisplay === "function" && typeof node.getComputedTop === "function" && typeof node.getComputedHeight === "function";
+}
+function createInkRenderCull(options) {
+  const { clip: originalClip, unclip: originalUnclip, displayNone } = options;
+  const cullMark = /* @__PURE__ */ Symbol("book.inkRenderCullDisplay");
+  const clips = /* @__PURE__ */ new WeakMap();
+  let activeClipStack = null;
+  let frame = 0;
+  const absoluteTops = /* @__PURE__ */ new WeakMap();
+  const scannedChildren = /* @__PURE__ */ new WeakMap();
+  const nodeRecords = /* @__PURE__ */ new WeakMap();
+  const clip = function(pushed) {
+    let stack = clips.get(this);
+    if (stack === void 0) {
+      frame++;
+      stack = [];
+      clips.set(this, stack);
+    }
+    activeClipStack = stack;
+    stack.push(pushed);
+    originalClip.call(this, pushed);
+  };
+  Object.defineProperty(clip, INSTALLED_MARK2, { value: true });
+  const unclip = function() {
+    clips.get(this)?.pop();
+    originalUnclip.call(this);
+  };
+  const getAbsoluteTop = (node) => {
+    const cached = absoluteTops.get(node);
+    if (cached !== void 0 && cached.frame === frame) {
+      return cached.top;
+    }
+    const nodeTop = node.yogaNode?.getComputedTop();
+    if (typeof nodeTop !== "number") {
+      absoluteTops.set(node, { frame, top: void 0 });
+      return void 0;
+    }
+    let parentTop = 0;
+    if (node.parentNode != null) {
+      const parentAbsoluteTop = getAbsoluteTop(node.parentNode);
+      if (parentAbsoluteTop === void 0) {
+        absoluteTops.set(node, { frame, top: void 0 });
+        return void 0;
+      }
+      parentTop = parentAbsoluteTop;
+    }
+    const totalTop = parentTop + nodeTop;
+    absoluteTops.set(node, { frame, top: totalTop });
+    return totalTop;
+  };
+  function sharedGetDisplay() {
+    const record = nodeRecords.get(this);
+    if (record === void 0) {
+      const stored = this[REAL_DISPLAY];
+      if (typeof stored === "function") return stored.call(this);
+      const proto = Object.getPrototypeOf(this);
+      if (typeof proto?.getDisplay === "function") return proto.getDisplay.call(this);
+      return displayNone;
+    }
+    const { element, realDisplay } = record;
+    const display = realDisplay.call(this);
+    if (display === displayNone) return display;
+    if (activeClipStack === null || activeClipStack.length === 0) return display;
+    const innermost = activeClipStack.at(-1);
+    if (innermost === void 0) return display;
+    const { y1, y2 } = innermost;
+    if (typeof y1 !== "number" || typeof y2 !== "number") return display;
+    const top = getAbsoluteTop(element);
+    if (top === void 0) return display;
+    const bottom = top + this.getComputedHeight();
+    const style = element.style;
+    const clipsSelf = style !== void 0 && (style.overflow === "hidden" || style.overflowX === "hidden" || style.overflowY === "hidden");
+    const straddles = top < y1 && bottom > y1 || top < y2 && bottom > y2;
+    if (straddles) {
+      const currentChildren = element.childNodes;
+      let currentLength = 0;
+      let firstChild;
+      let lastChild;
+      if (Array.isArray(currentChildren)) {
+        currentLength = currentChildren.length;
+        if (currentLength > 0) {
+          firstChild = currentChildren[0];
+          lastChild = currentChildren[currentLength - 1];
+        }
+      } else if (currentChildren && typeof currentChildren[Symbol.iterator] === "function") {
+        const items = Array.from(currentChildren);
+        currentLength = items.length;
+        if (currentLength > 0) {
+          firstChild = items[0];
+          lastChild = items[currentLength - 1];
+        }
+      }
+      const lastScanned = scannedChildren.get(element);
+      if (lastScanned === void 0 || lastScanned.length !== currentLength || lastScanned.firstChild !== firstChild || lastScanned.lastChild !== lastChild) {
+        scannedChildren.set(element, {
+          length: currentLength,
+          firstChild,
+          lastChild
+        });
+        if (currentChildren && typeof currentChildren[Symbol.iterator] === "function") {
+          for (const child of currentChildren) {
+            cull.cullWhenOffscreen(child);
+          }
+        }
+      }
+    }
+    if (clipsSelf) return display;
+    if (bottom <= y1 || top >= y2) return displayNone;
+    return display;
+  }
+  const cull = {
+    clip,
+    unclip,
+    cullWhenOffscreen: (element) => {
+      if (element === null || typeof element !== "object") return;
+      const yogaNode = element.yogaNode;
+      if (!isCullableYogaNode(yogaNode)) return;
+      const marked = yogaNode;
+      if (marked[cullMark] === true) return;
+      let realDisplay = marked[REAL_DISPLAY];
+      if (typeof realDisplay !== "function") {
+        realDisplay = yogaNode.getDisplay;
+        Object.defineProperty(yogaNode, REAL_DISPLAY, { value: realDisplay, configurable: true });
+      }
+      nodeRecords.set(yogaNode, { element, realDisplay });
+      Object.defineProperty(yogaNode, "getDisplay", {
+        value: sharedGetDisplay,
+        configurable: true
+      });
+      Object.defineProperty(yogaNode, cullMark, { value: true, configurable: true });
+    }
+  };
+  return cull;
+}
+function isRenderCullInstalled(candidate) {
+  if (typeof candidate !== "function") return false;
+  const prototype = candidate.prototype;
+  const clip = prototype?.clip;
+  return typeof clip === "function" && clip[INSTALLED_MARK2] === true;
+}
+function isInkRenderCullShape(candidate) {
+  if (typeof candidate !== "function") return false;
+  const prototype = candidate.prototype;
+  if (typeof prototype !== "object" || prototype === null) return false;
+  const { clip, unclip, get } = prototype;
+  return typeof clip === "function" && typeof unclip === "function" && typeof get === "function";
+}
+var activeCull = null;
+function cullWhenOffscreen(element) {
+  activeCull?.(element);
+}
+async function installInkRenderCull(env = process.env) {
+  try {
+    const outputPath = join3(inkBuildDir(), "output.js");
+    const outputModule = await import(pathToFileURL3(outputPath).href);
+    if (isRenderCullInstalled(outputModule.default)) return true;
+    if (parseEnvBoolean(env.BOOK_INK_RENDER_CULL) === false) return false;
+    const yogaPath = createRequire3(outputPath).resolve("yoga-layout");
+    const yoga = await import(pathToFileURL3(yogaPath).href);
+    const displayNone = yoga.default?.DISPLAY_NONE;
+    if (typeof displayNone !== "number") return false;
+    if (!isInkRenderCullShape(outputModule.default)) return false;
+    const { prototype } = outputModule.default;
+    const cull = createInkRenderCull({
+      clip: prototype.clip,
+      unclip: prototype.unclip,
+      displayNone
+    });
+    prototype.clip = cull.clip;
+    prototype.unclip = cull.unclip;
+    activeCull = cull.cullWhenOffscreen;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/ink-frame-clip.ts
+import { createRequire as createRequire4 } from "module";
+import { join as join4 } from "path";
+import { pathToFileURL as pathToFileURL4 } from "url";
+var INSTALLED_MARK3 = /* @__PURE__ */ Symbol("book.inkFrameClip");
+var TAB_STOP = 8;
+function expandTabs(row, measure) {
+  const parts = row.split("	");
+  let expanded = parts[0] ?? "";
+  let column = measure(expanded);
+  for (let index = 1; index < parts.length; index++) {
+    const part = parts[index] ?? "";
+    const pad = TAB_STOP - column % TAB_STOP;
+    expanded += " ".repeat(pad) + part;
+    column += pad + measure(part);
+  }
+  return expanded;
+}
+function clipsWithinWidth(clip, width) {
+  return typeof clip?.x1 === "number" && typeof clip.x2 === "number" && clip.x2 <= width;
+}
+function rowsPastWidth(output) {
+  let rows = null;
+  const clips = [];
+  for (const operation of output.operations) {
+    if (operation.type === "clip") {
+      clips.push(operation.clip);
+      continue;
+    }
+    if (operation.type === "unclip") {
+      clips.pop();
+      continue;
+    }
+    const { x, y, text } = operation;
+    if (!text.includes("	")) {
+      if (clipsWithinWidth(clips.at(-1), output.width)) continue;
+      if (x + 2 * text.length <= output.width) continue;
+      if (x + output.caches.getWidestLine(text) <= output.width) continue;
+    }
+    rows ??= new Array(output.height).fill(false);
+    let lines = 1;
+    for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) {
+      lines++;
+    }
+    const last = Math.min(y + lines, output.height);
+    for (let row = Math.max(y, 0); row < last; row++) rows[row] = true;
+  }
+  return rows;
+}
+function createFrameClippedGet(options) {
+  const { get, sliceAnsi, stringWidth } = options;
+  const clipped = function() {
+    const frame = get.call(this);
+    const candidates = rowsPastWidth(this);
+    if (candidates === null) return frame;
+    const caches = this.caches;
+    const measure = typeof caches?.getStringWidth === "function" ? caches.getStringWidth.bind(caches) : stringWidth;
+    const width = this.width;
+    const rows = frame.output.split("\n");
+    const checkAll = rows.length !== frame.height;
+    let changed = false;
+    for (let row = 0; row < rows.length; row++) {
+      if (!checkAll && !candidates[row]) continue;
+      const original = rows[row] ?? "";
+      let text = original.includes("	") ? expandTabs(original, measure) : original;
+      if (measure(text) > width) text = sliceAnsi(text, 0, width).trimEnd();
+      if (text === original) continue;
+      rows[row] = text;
+      changed = true;
+    }
+    return changed ? { output: rows.join("\n"), height: frame.height } : frame;
+  };
+  for (const symbol of Object.getOwnPropertySymbols(get)) {
+    const descriptor = Object.getOwnPropertyDescriptor(get, symbol);
+    if (descriptor) Object.defineProperty(clipped, symbol, descriptor);
+  }
+  Object.defineProperty(clipped, INSTALLED_MARK3, { value: true });
+  return clipped;
+}
+function isFrameClippedGet(Output) {
+  if (typeof Output !== "function") return false;
+  const prototype = Output.prototype;
+  const get = prototype?.get;
+  return get?.[INSTALLED_MARK3] === true;
+}
+function isClippableOutput(Output) {
+  if (!isInkOutputShape(Output)) return false;
+  try {
+    return new Output({ width: 3, height: 1 }).width === 3;
+  } catch {
+    return false;
+  }
+}
+async function installInkFrameClip(env = process.env) {
+  try {
+    const outputPath = join4(inkBuildDir(), "output.js");
+    const outputModule = await import(pathToFileURL4(outputPath).href);
+    const Output = outputModule.default;
+    if (isFrameClippedGet(Output)) return true;
+    if (parseEnvBoolean(env.BOOK_INK_FRAME_CLIP) === false) return false;
+    const require2 = createRequire4(outputPath);
+    const [sliceAnsiModule, stringWidthModule] = await Promise.all([
+      import(pathToFileURL4(require2.resolve("slice-ansi")).href),
+      import(pathToFileURL4(require2.resolve("string-width")).href)
+    ]);
+    const sliceAnsi = sliceAnsiModule.default;
+    const stringWidth = stringWidthModule.default;
+    if (!isClippableOutput(Output)) return false;
+    if (typeof sliceAnsi !== "function" || typeof stringWidth !== "function") return false;
+    Output.prototype.get = createFrameClippedGet({
+      get: Output.prototype.get,
+      sliceAnsi,
+      stringWidth
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/tui-renderer-mode.ts
+function resolveTuiRendererMode(value = process.env.BOOK_TUI_RENDERER, context = {}) {
+  if (context.isTTY === false || context.screenReader) return "safe";
+  if (context.incrementalRendererFixed === false) return "safe";
+  if (value === "incremental") return "incremental";
+  if (value === "experimental-scroll") return "experimental-scroll";
+  if (value === void 0) return context.platform === "win32" ? "safe" : "incremental";
+  return "safe";
+}
+function isCiEnvironment(env = process.env) {
+  const set = (key) => key in env && env[key] !== "0" && env[key] !== "false";
+  return set("CI") || set("CONTINUOUS_INTEGRATION");
+}
+function resolveInkMaxFps(platform = process.platform) {
+  return platform === "win32" ? 72 : 60;
+}
+
+export {
+  DEFAULT_PROVIDER_BASE_URLS,
+  normalizeProviderBaseUrl,
+  discoverModels,
+  validateApiKey,
+  providerKeyTarget,
+  deleteProviderConnectionKeys,
+  writeProviderKey,
+  checkProviderKey,
+  inkBuildDir,
+  hasInkTrailingNewlineFix,
+  loadInkFlushSync,
+  setTranscriptScrollHint,
+  installInkScrollRenderer,
+  getFrameLines,
+  getLastCursorPosition,
+  subscribeToFrameUpdates,
+  installFrameCapture,
+  installInkOutputCache,
+  cullWhenOffscreen,
+  installInkRenderCull,
+  expandTabs,
+  installInkFrameClip,
+  resolveTuiRendererMode,
+  isCiEnvironment,
+  resolveInkMaxFps
+};
+//# sourceMappingURL=chunk-ECLC4CIJ.js.map