@ponythewhite/base-context 1.0.0 → 1.0.1

package/dist/bundle/chunk-27QCJ2AZ.js

@@ -0,0 +1,2578 @@
+import { createRequire as __piBundleCreateRequire } from 'node:module'; const require = __piBundleCreateRequire(import.meta.url);
+import {
+  cleanupSessionResources,
+  registerSessionResourceCleanup
+} from "./chunk-5QCJ5DQU.js";
+import {
+  AddImmutable,
+  AddImmutableDeferred,
+  AddOptional,
+  AddOptionalDeferred,
+  AddReadonly,
+  AddReadonlyDeferred,
+  Any,
+  ArrayOptions,
+  BigInt,
+  BigIntPattern,
+  Boolean,
+  Broaden,
+  Call,
+  CallConstruct,
+  Capitalize,
+  CapitalizeAction,
+  CapitalizeDeferred,
+  CapitalizeInstantiate,
+  Codec,
+  CollapseToObject,
+  Compare,
+  Compile,
+  Composite,
+  Conditional,
+  ConditionalAction,
+  ConditionalDeferred,
+  ConditionalInstantiate,
+  Constructor,
+  ConstructorOptions,
+  ConstructorParameters,
+  ConstructorParametersAction,
+  ConstructorParametersDeferred,
+  ConstructorParametersInstantiate,
+  ConvertToIntegerKey,
+  Cyclic,
+  CyclicCandidates,
+  CyclicCheck,
+  CyclicDependencies,
+  CyclicExtends,
+  CyclicOptions,
+  CyclicTarget,
+  Decode,
+  DecodeBuilder,
+  Deferred,
+  Dependent,
+  DependentOptions,
+  Distribute,
+  Encode,
+  EncodeBuilder,
+  Enum,
+  Evaluate,
+  EvaluateAction,
+  EvaluateDeferred,
+  EvaluateDependent,
+  EvaluateEnum,
+  EvaluateInstantiate,
+  EvaluateIntersect,
+  EvaluateTemplateLiteral,
+  EvaluateType,
+  EvaluateUnion,
+  EvaluateUnionFast,
+  Exclude,
+  ExcludeAction,
+  ExcludeDeferred,
+  ExcludeInstantiate,
+  Extends,
+  Extract,
+  ExtractAction,
+  ExtractDeferred,
+  ExtractInstantiate,
+  Flatten,
+  FunctionOptions,
+  Generic,
+  Identifier,
+  Immutable,
+  Index,
+  IndexAction,
+  IndexDeferred,
+  IndexInstantiate,
+  Infer,
+  InstanceType,
+  InstanceTypeAction,
+  InstanceTypeDeferred,
+  InstanceTypeInstantiate,
+  Instantiate,
+  InstantiateCyclic,
+  Integer,
+  IntegerKey,
+  IntegerPattern,
+  Interface,
+  InterfaceAction,
+  InterfaceDeferred,
+  InterfaceInstantiate,
+  Intersect,
+  IntersectOptions,
+  InvalidLiteralValue,
+  IsAny,
+  IsArray,
+  IsBigInt,
+  IsBoolean,
+  IsCall,
+  IsCodec,
+  IsConstructor,
+  IsCyclic,
+  IsDeferred,
+  IsDependent,
+  IsEnum,
+  IsEnumValue,
+  IsFunction,
+  IsGeneric,
+  IsIdentifier,
+  IsImmutable,
+  IsInfer,
+  IsInteger,
+  IsInterfaceDeferred,
+  IsIntersect,
+  IsKind,
+  IsLiteral,
+  IsLiteralBigInt,
+  IsLiteralBoolean,
+  IsLiteralNumber,
+  IsLiteralString,
+  IsLiteralValue,
+  IsNever,
+  IsNull,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsParameter,
+  IsReadonly,
+  IsRecord,
+  IsRef,
+  IsRefine,
+  IsRefinement,
+  IsRest,
+  IsSchema,
+  IsString,
+  IsSymbol,
+  IsTemplateLiteral,
+  IsTemplateLiteralDeferred,
+  IsTemplateLiteralFinite,
+  IsTemplateLiteralPattern,
+  IsThis,
+  IsTuple,
+  IsTypeScriptEnumLike,
+  IsUndefined,
+  IsUnion,
+  IsUnknown,
+  IsUnsafe,
+  IsVoid,
+  KeyOf,
+  KeyOfAction,
+  KeyOfDeferred,
+  KeyOfInstantiate,
+  KeysToIndexer,
+  Literal,
+  LiteralTypeName,
+  Lowercase,
+  LowercaseAction,
+  LowercaseDeferred,
+  LowercaseInstantiate,
+  Mapped,
+  MappedAction,
+  MappedDeferred,
+  MappedInstantiate,
+  Module,
+  ModuleDeferred,
+  ModuleInstantiate,
+  Narrow,
+  Never,
+  NeverPattern,
+  NonNullable,
+  NonNullableAction,
+  NonNullableDeferred,
+  NonNullableInstantiate,
+  Null,
+  Number as Number2,
+  NumberKey,
+  NumberPattern,
+  ObjectOptions,
+  Omit,
+  OmitAction,
+  OmitDeferred,
+  OmitInstantiate,
+  Optional,
+  Parameter,
+  Parameters,
+  ParametersAction,
+  ParametersDeferred,
+  ParametersInstantiate,
+  ParsePatternIntoTypes,
+  ParseTemplateIntoTypes,
+  Partial,
+  PartialAction,
+  PartialDeferred,
+  PartialInstantiate,
+  Pick,
+  PickAction,
+  PickDeferred,
+  PickInstantiate,
+  Priority,
+  PropertyKeys,
+  PropertyValues,
+  Readonly,
+  ReadonlyObject,
+  ReadonlyObjectAction,
+  ReadonlyObjectDeferred,
+  ReadonlyObjectInstantiate,
+  ReadonlyType,
+  Record,
+  RecordAction,
+  RecordDeferred,
+  RecordFromPattern,
+  RecordInstantiate,
+  RecordKey,
+  RecordOptions,
+  RecordPattern,
+  RecordPatternToType,
+  RecordValue,
+  Ref,
+  RefInstantiate,
+  Refine,
+  RefineAdd,
+  RemoveImmutable,
+  RemoveImmutableDeferred,
+  RemoveOptional,
+  RemoveOptionalDeferred,
+  RemoveReadonly,
+  RemoveReadonlyDeferred,
+  Required,
+  RequiredAction,
+  RequiredArray,
+  RequiredDeferred,
+  RequiredInstantiate,
+  Rest,
+  ResultDisjoint,
+  ResultEqual,
+  ResultLeftInside,
+  ResultRightInside,
+  ReturnType,
+  ReturnTypeAction,
+  ReturnTypeDeferred,
+  ReturnTypeInstantiate,
+  Script,
+  String as String2,
+  StringKey,
+  StringPattern,
+  Symbol as Symbol2,
+  TemplateLiteral,
+  TemplateLiteralCreate,
+  TemplateLiteralDecode,
+  TemplateLiteralDecodeUnsafe,
+  TemplateLiteralDeferred,
+  TemplateLiteralEncode,
+  TemplateLiteralFromString,
+  TemplateLiteralFromTypes,
+  This,
+  Tuple,
+  TupleOptions,
+  TypeScriptEnumToEnumValues,
+  Uncapitalize,
+  UncapitalizeAction,
+  UncapitalizeDeferred,
+  UncapitalizeInstantiate,
+  Undefined,
+  Union,
+  UnionOptions,
+  Unknown,
+  Unsafe,
+  Uppercase,
+  UppercaseAction,
+  UppercaseDeferred,
+  UppercaseInstantiate,
+  Void,
+  With,
+  WithAction,
+  WithDeferred,
+  WithInstantiate,
+  _Array_,
+  _Function_,
+  _Object_,
+  result_exports,
+  value_exports
+} from "./chunk-CRBVRZBV.js";
+import {
+  PRODUCT,
+  PRODUCT_ENV
+} from "./chunk-GRJFXLBM.js";
+import {
+  parseJsonWithRepair,
+  parseStreamingJson,
+  repairJson
+} from "./chunk-2T7M7VJ4.js";
+import {
+  findEnvKeys,
+  getEnvApiKey
+} from "./chunk-DGNX7HQ3.js";
+import {
+  AssistantMessageEventStream,
+  EventStream,
+  RequestTokenBudget,
+  RequestTokenBudgetError,
+  StreamFailureError,
+  appendAssistantMessageDiagnostic,
+  calculateCost,
+  clampThinkingLevel,
+  classifyStreamFailure,
+  createAssistantMessageDiagnostic,
+  createAssistantMessageEventStream,
+  extractDiagnosticError,
+  extractStreamFailureInfo,
+  formatStreamFailureMessage,
+  formatThrownValue,
+  getLogger,
+  getModel,
+  getModels,
+  getProviders,
+  getSupportedThinkingLevels,
+  invokeRequestMeasurement,
+  isLocalRequestPreparationError,
+  isTransientProviderFailure,
+  markLocalRequestPreparationError,
+  modelsAreEqual,
+  recordStreamFailure,
+  requestTokenRouteIdentity,
+  setLogSink,
+  streamFailureFromStopReason,
+  streamFailureMessage,
+  stringifyLogEntry,
+  supportsFastMode,
+  truncateRawPayload,
+  withRequestBody
+} from "./chunk-W46VZFI6.js";
+import {
+  __export
+} from "./chunk-BAWSWWEU.js";
+
+// dist/runtime-paths.js
+import { lstatSync, readlinkSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function expandHomePath(path, home = homedir()) {
+  if (path === "~")
+    return home;
+  if (path.startsWith("~/"))
+    return join(home, path.slice(2));
+  return path;
+}
+function readAbsolutePathEnv(name, env = process.env, home = homedir()) {
+  const value = env[name];
+  if (value === void 0)
+    return void 0;
+  const expanded = expandHomePath(value, home);
+  if (!value.trim() || !isAbsolute(expanded)) {
+    throw new Error(`${name} must be a non-empty absolute path (~/ is supported).`);
+  }
+  return resolve(expanded);
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  try {
+    if (lstatSync(path).isSymbolicLink())
+      return canonicalPath(resolve(dirname(path), readlinkSync(path)));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const parent = dirname(path);
+  return parent === path ? path : join(canonicalPath(parent), relative(parent, path));
+}
+function assertProductStatePath(path, home = homedir()) {
+  const canonical = canonicalPath(resolve(path));
+  for (const directory of [".prime", ".pi", ".prime-context"]) {
+    const legacy = canonicalPath(join(home, directory));
+    const rel = relative(legacy, canonical);
+    if (resolve(path).split(sep).includes(directory) || canonical.split(sep).includes(directory) || rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) {
+      throw new Error(`Base Context cannot write legacy state at ${path}. Choose a separate BASE_CONTEXT_HOME; use explicit import for legacy data.`);
+    }
+  }
+  return resolve(path);
+}
+function resolveRuntimePaths(env = process.env, home = homedir(), cwd = process.cwd()) {
+  const root = assertProductStatePath(readAbsolutePathEnv(PRODUCT_ENV.home, env, home) ?? join(home, PRODUCT.configDirectory), home);
+  const sessions = assertProductStatePath(readAbsolutePathEnv(PRODUCT_ENV.sessions, env, home) ?? join(root, "sessions"), home);
+  return Object.freeze({
+    home: root,
+    project: assertProductStatePath(join(cwd, PRODUCT.configDirectory), home),
+    sessions,
+    runtime: assertProductStatePath(join(root, "runtime"), home),
+    auth: assertProductStatePath(join(root, "auth.json"), home),
+    daemonRegistry: assertProductStatePath(join(root, "daemon-supervisors"), home)
+  });
+}
+
+// dist/utils/daemon-socket-path.js
+import { resolve as resolve2 } from "node:path";
+function normalizeSocketPath(socketPath, baseDir) {
+  if (process.platform === "win32") {
+    return socketPath.toLowerCase();
+  }
+  return baseDir ? resolve2(baseDir, socketPath) : resolve2(socketPath);
+}
+
+// dist/config.js
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { accessSync, appendFileSync, constants as constants2, existsSync, mkdirSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, rmSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve3, sep as sep2, win32 } from "path";
+import { fileURLToPath } from "url";
+
+// dist/utils/child-process.js
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { constants } from "node:os";
+import { basename } from "node:path";
+var EXIT_STDIO_GRACE_MS = 100;
+var WINDOWS_SHELL_COMMANDS = /* @__PURE__ */ new Set(["npm", "npx", "pnpm", "yarn", "yarnpkg", "corepack"]);
+function shouldUseWindowsShell(command) {
+  if (process.platform !== "win32")
+    return false;
+  const commandName = basename(command).toLowerCase();
+  return commandName.endsWith(".cmd") || commandName.endsWith(".bat") || WINDOWS_SHELL_COMMANDS.has(commandName);
+}
+function processIdExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function isZombieProcess(pid) {
+  if (process.platform === "win32") {
+    return false;
+  }
+  try {
+    const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+    const state = stat.slice(stat.lastIndexOf(")") + 2).trimStart().charAt(0);
+    return state === "Z";
+  } catch {
+  }
+  try {
+    const state = execFileSync("ps", ["-p", String(pid), "-o", "stat="], { encoding: "utf8" }).trim();
+    return state.startsWith("Z");
+  } catch {
+    return false;
+  }
+}
+function isProcessAlive(pid) {
+  return processIdExists(pid) && !isZombieProcess(pid);
+}
+function signalProcessGroupOrProcess(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return;
+  } catch {
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
+function signalExitCode(signal) {
+  if (!signal)
+    return null;
+  const signalNumber = constants.signals[signal];
+  return signalNumber === void 0 ? 1 : 128 + signalNumber;
+}
+function normalizedExitCode(code, signal) {
+  return code ?? signalExitCode(signal);
+}
+function waitForChildProcess(child) {
+  return new Promise((resolve4, reject) => {
+    let settled = false;
+    let exited = false;
+    let exitCode = null;
+    let exitSignal = null;
+    let postExitTimer;
+    let stdoutEnded = child.stdout === null || child.stdout.readableEnded;
+    let stderrEnded = child.stderr === null || child.stderr.readableEnded;
+    const cleanup = () => {
+      if (postExitTimer) {
+        clearTimeout(postExitTimer);
+        postExitTimer = void 0;
+      }
+      child.removeListener("error", onError);
+      child.removeListener("exit", onExit);
+      child.removeListener("close", onClose);
+      child.stdout?.removeListener("end", onStdoutEnd);
+      child.stderr?.removeListener("end", onStderrEnd);
+    };
+    const finalize = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve4(code);
+    };
+    const maybeFinalizeAfterExit = () => {
+      if (!exited || settled)
+        return;
+      if (stdoutEnded && stderrEnded) {
+        finalize(normalizedExitCode(exitCode, exitSignal));
+      }
+    };
+    const onStdoutEnd = () => {
+      stdoutEnded = true;
+      maybeFinalizeAfterExit();
+    };
+    const onStderrEnd = () => {
+      stderrEnded = true;
+      maybeFinalizeAfterExit();
+    };
+    const onError = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onExit = (code, signal = null) => {
+      exited = true;
+      exitCode = code;
+      exitSignal = signal;
+      maybeFinalizeAfterExit();
+      if (!settled) {
+        postExitTimer = setTimeout(() => finalize(normalizedExitCode(code, signal)), EXIT_STDIO_GRACE_MS);
+      }
+    };
+    const onClose = (code, signal = null) => {
+      finalize(normalizedExitCode(code, signal));
+    };
+    child.stdout?.once("end", onStdoutEnd);
+    child.stderr?.once("end", onStderrEnd);
+    child.once("error", onError);
+    child.once("exit", onExit);
+    child.once("close", onClose);
+    if (child.exitCode !== null || child.signalCode !== null) {
+      onExit(child.exitCode, child.signalCode);
+    }
+  });
+}
+
+// dist/config.js
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var isBunBinary = import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+var isBunRuntime = !!process.versions.bun;
+var SELF_UPDATE_INTERACTIVE_CHILD_ENV = PRODUCT_ENV.interactiveSelfUpdate;
+var SELF_UPDATE_NOT_ATTEMPTED_EXIT_CODE = 75;
+function makeSelfUpdateCommand(installStep, uninstallStep, options = {}) {
+  if (!uninstallStep)
+    return installStep;
+  if (options.uninstallAfterInstall) {
+    return {
+      ...installStep,
+      display: `${installStep.display} && ${uninstallStep.display}`,
+      steps: [installStep, uninstallStep]
+    };
+  }
+  return {
+    ...installStep,
+    display: `${uninstallStep.display} && ${installStep.display}`,
+    steps: [uninstallStep, installStep]
+  };
+}
+function makeSelfUpdateCommandStep(command, args) {
+  return {
+    command,
+    args,
+    display: [command, ...args].map((arg) => /\s/.test(arg) ? `"${arg}"` : arg).join(" ")
+  };
+}
+function detectInstallMethod() {
+  if (isBunBinary) {
+    return "bun-binary";
+  }
+  if (isHomebrewInstall()) {
+    return "homebrew";
+  }
+  const resolvedPath = `${__dirname}\0${process.execPath || ""}`.toLowerCase().replace(/\\/g, "/");
+  if (resolvedPath.includes("/pnpm/") || resolvedPath.includes("/.pnpm/")) {
+    return "pnpm";
+  }
+  if (resolvedPath.includes("/yarn/") || resolvedPath.includes("/.yarn/")) {
+    return "yarn";
+  }
+  if (isBunRuntime || resolvedPath.includes("/install/global/node_modules/")) {
+    return "bun";
+  }
+  if (resolvedPath.includes("/npm/") || resolvedPath.includes("/node_modules/")) {
+    return "npm";
+  }
+  return "unknown";
+}
+function isHomebrewInstall() {
+  const packageDir = getPackageDir().toLowerCase().replace(/\\/g, "/");
+  return packageDir.includes("/cellar/") && packageDir.includes("/libexec/lib/node_modules/");
+}
+function getInferredNpmInstall() {
+  const packageDir = getPackageDir();
+  const path = process.platform === "win32" || packageDir.includes("\\") ? win32 : { basename: basename2, dirname: dirname2 };
+  const parent = path.dirname(packageDir);
+  let root;
+  if (path.basename(parent).startsWith("@") && path.basename(path.dirname(parent)) === "node_modules") {
+    root = path.dirname(parent);
+  } else if (path.basename(parent) === "node_modules") {
+    root = parent;
+  }
+  if (!root)
+    return void 0;
+  const rootParent = path.dirname(root);
+  if (path.basename(rootParent) === "lib")
+    return { root, prefix: path.dirname(rootParent) };
+  return void 0;
+}
+function isDirectPackageArtifactSpec(updateSpec) {
+  const spec = updateSpec.trim().toLowerCase();
+  return spec.startsWith("http://") || spec.startsWith("https://") || spec.startsWith("file:") || spec.endsWith(".tgz") || spec.endsWith(".tar.gz");
+}
+function getDefaultUpdatePackageName(installedPackageName, updateSpec) {
+  if (isDirectPackageArtifactSpec(updateSpec)) {
+    return installedPackageName;
+  }
+  return updateSpec;
+}
+function getSelfUpdateCommandForMethod(method, installedPackageName, updateSpec = installedPackageName, npmCommand, updatePackageName = getDefaultUpdatePackageName(installedPackageName, updateSpec)) {
+  const uninstallAfterInstall = isDirectPackageArtifactSpec(updateSpec);
+  switch (method) {
+    case "bun-binary":
+    case "homebrew":
+      return void 0;
+    case "pnpm":
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("pnpm", ["install", "-g", updateSpec]), updatePackageName === installedPackageName ? void 0 : makeSelfUpdateCommandStep("pnpm", ["remove", "-g", installedPackageName]), { uninstallAfterInstall });
+    case "yarn":
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("yarn", ["global", "add", updateSpec]), updatePackageName === installedPackageName ? void 0 : makeSelfUpdateCommandStep("yarn", ["global", "remove", installedPackageName]), { uninstallAfterInstall });
+    case "bun":
+      return makeSelfUpdateCommand(makeSelfUpdateCommandStep("bun", ["install", "-g", updateSpec]), updatePackageName === installedPackageName ? void 0 : makeSelfUpdateCommandStep("bun", ["uninstall", "-g", installedPackageName]), { uninstallAfterInstall });
+    case "npm": {
+      const [command = "npm", ...npmArgs] = npmCommand ?? [];
+      const inferred = npmCommand?.length ? void 0 : getInferredNpmInstall();
+      const prefixArgs = [...npmArgs, ...inferred ? ["--prefix", inferred.prefix] : []];
+      const installStep = makeSelfUpdateCommandStep(command, [...prefixArgs, "install", "-g", updateSpec]);
+      const uninstallStep = updatePackageName === installedPackageName ? void 0 : makeSelfUpdateCommandStep(command, [...prefixArgs, "uninstall", "-g", installedPackageName]);
+      return makeSelfUpdateCommand(installStep, uninstallStep, { uninstallAfterInstall });
+    }
+    case "unknown":
+      return void 0;
+  }
+}
+function readCommandOutput(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: shouldUseWindowsShell(command)
+  });
+  if (result.status === 0)
+    return result.stdout.trim() || void 0;
+  if (options.requireSuccess) {
+    const reason = result.error?.message || result.stderr.trim() || `exit code ${result.status ?? "unknown"}`;
+    throw new Error(`Failed to run ${[command, ...args].join(" ")}: ${reason}`);
+  }
+  return void 0;
+}
+function getGlobalPackageRoots(method, _packageName, npmCommand) {
+  switch (method) {
+    case "npm": {
+      const configured = !!npmCommand?.length;
+      const [command = "npm", ...npmArgs] = npmCommand ?? [];
+      if (configured && command === "bun") {
+        const bunBin = readCommandOutput(command, [...npmArgs, "pm", "bin", "-g"], {
+          requireSuccess: true
+        });
+        const roots = [join2(homedir2(), ".bun", "install", "global", "node_modules")];
+        if (bunBin) {
+          roots.push(join2(dirname2(bunBin), "install", "global", "node_modules"));
+        }
+        return roots;
+      }
+      const root = readCommandOutput(command, [...npmArgs, "root", "-g"], {
+        requireSuccess: configured
+      });
+      const inferred = configured ? void 0 : getInferredNpmInstall();
+      return [root, inferred?.root].filter((x) => !!x);
+    }
+    case "pnpm": {
+      const root = readCommandOutput("pnpm", ["root", "-g"]);
+      return root ? [root, dirname2(root)] : [];
+    }
+    case "yarn": {
+      const dir = readCommandOutput("yarn", ["global", "dir"]);
+      return dir ? [dir, join2(dir, "node_modules")] : [];
+    }
+    case "bun": {
+      const bunBin = readCommandOutput("bun", ["pm", "bin", "-g"]);
+      const roots = [join2(homedir2(), ".bun", "install", "global", "node_modules")];
+      if (bunBin) {
+        roots.push(join2(dirname2(bunBin), "install", "global", "node_modules"));
+      }
+      return roots;
+    }
+    case "bun-binary":
+    case "homebrew":
+    case "unknown":
+      return [];
+  }
+}
+function normalizeExistingPathForComparison(path) {
+  const resolvedPath = resolve3(path);
+  if (!existsSync(resolvedPath)) {
+    return void 0;
+  }
+  let normalizedPath;
+  try {
+    normalizedPath = realpathSync2(resolvedPath);
+  } catch {
+    return void 0;
+  }
+  if (process.platform === "win32") {
+    normalizedPath = normalizedPath.toLowerCase();
+  }
+  return normalizedPath;
+}
+function isSelfUpdatePathWritable() {
+  const packageDir = getPackageDir();
+  try {
+    accessSync(packageDir, constants2.W_OK);
+    accessSync(dirname2(packageDir), constants2.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isManagedByGlobalPackageManager(method, packageName, npmCommand) {
+  const packageDir = normalizeExistingPathForComparison(getPackageDir());
+  return !!packageDir && getGlobalPackageRoots(method, packageName, npmCommand).some((root) => {
+    const normalizedRoot = normalizeExistingPathForComparison(root);
+    return !!normalizedRoot && packageDir.startsWith(normalizedRoot.endsWith(sep2) ? normalizedRoot : `${normalizedRoot}${sep2}`);
+  });
+}
+function getSelfUpdateCommand(packageName, npmCommand, updateSpec = packageName, updatePackageName = getDefaultUpdatePackageName(packageName, updateSpec)) {
+  const method = detectInstallMethod();
+  const command = getSelfUpdateCommandForMethod(method, packageName, updateSpec, npmCommand, updatePackageName);
+  if (!command || !isManagedByGlobalPackageManager(method, packageName, npmCommand) || !isSelfUpdatePathWritable()) {
+    return void 0;
+  }
+  return command;
+}
+function getSelfUpdateUnavailableInstruction(packageName, npmCommand, updateSpec = packageName, updatePackageName = getDefaultUpdatePackageName(packageName, updateSpec)) {
+  const method = detectInstallMethod();
+  if (method === "bun-binary") {
+    return `Download from: ${PRODUCT.repository}/releases/latest`;
+  }
+  if (method === "homebrew") {
+    return `Update with: brew upgrade ${APP_NAME}`;
+  }
+  const command = getSelfUpdateCommandForMethod(method, packageName, updateSpec, npmCommand, updatePackageName);
+  if (command) {
+    if (isManagedByGlobalPackageManager(method, packageName, npmCommand) && !isSelfUpdatePathWritable()) {
+      return `This installation is managed by a global ${method} install, but the install path is not writable. Update it yourself with: ${command.display}`;
+    }
+    return `This installation is not managed by a global ${method} install. Update it with the package manager, wrapper, or source checkout that provides it.`;
+  }
+  return `Update ${updateSpec} using the package manager, wrapper, or source checkout that provides this installation.`;
+}
+function getPackageDir() {
+  const envDir = process.env[PRODUCT_ENV.packageDirectory];
+  if (envDir) {
+    if (envDir === "~")
+      return homedir2();
+    if (envDir.startsWith("~/"))
+      return homedir2() + envDir.slice(1);
+    return envDir;
+  }
+  return getPhysicalPackageDir();
+}
+function getPhysicalPackageDir() {
+  if (isBunBinary) {
+    return dirname2(process.execPath);
+  }
+  let dir = __dirname;
+  while (dir !== dirname2(dir)) {
+    if (existsSync(join2(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname2(dir);
+  }
+  return __dirname;
+}
+function getThemesDir() {
+  if (isBunBinary) {
+    return join2(getPackageDir(), "theme");
+  }
+  const packageDir = getPackageDir();
+  const srcOrDist = existsSync(join2(packageDir, "src")) ? "src" : "dist";
+  return join2(packageDir, srcOrDist, "modes", "interactive", "theme");
+}
+function getExportTemplateDir() {
+  if (isBunBinary) {
+    return join2(getPackageDir(), "export-html");
+  }
+  const packageDir = getPackageDir();
+  const srcOrDist = existsSync(join2(packageDir, "src")) ? "src" : "dist";
+  return join2(packageDir, srcOrDist, "core", "export-html");
+}
+function getPackageJsonPath() {
+  return join2(getPackageDir(), "package.json");
+}
+function getDocsPath() {
+  return resolve3(join2(getPackageDir(), "docs"));
+}
+function getChangelogPath() {
+  return resolve3(join2(getPackageDir(), "CHANGELOG.md"));
+}
+function getInteractiveAssetsDir() {
+  if (isBunBinary) {
+    return join2(getPackageDir(), "assets");
+  }
+  const packageDir = getPackageDir();
+  const srcOrDist = existsSync(join2(packageDir, "src")) ? "src" : "dist";
+  return join2(packageDir, srcOrDist, "modes", "interactive", "assets");
+}
+function getBundledInteractiveAssetPath(name) {
+  return join2(getInteractiveAssetsDir(), name);
+}
+function getBundledSkillsDir() {
+  if (isBunBinary) {
+    return join2(getPackageDir(), "skills");
+  }
+  const packageDir = getPackageDir();
+  const isSourceCheckout = existsSync(join2(packageDir, "src"));
+  return isSourceCheckout ? join2(packageDir, "skills") : join2(packageDir, "dist", "skills");
+}
+var pkg = JSON.parse(readFileSync2(getPackageJsonPath(), "utf-8"));
+var PACKAGE_NAME = PRODUCT.packageName;
+var APP_NAME = PRODUCT.command;
+var APP_TITLE = PRODUCT.name;
+var CONFIG_DIR_NAME = PRODUCT.configDirectory;
+var VERSION = pkg.version || "0.0.0";
+var ENV_AGENT_DIR = PRODUCT_ENV.home;
+var ENV_SESSION_DIR = PRODUCT_ENV.sessions;
+function expandTildePath(path) {
+  return expandHomePath(path);
+}
+function getAgentDir() {
+  return resolveRuntimePaths().home;
+}
+function getCustomThemesDir() {
+  return join2(getAgentDir(), "themes");
+}
+function getLogsDir() {
+  return join2(getAgentDir(), "logs");
+}
+function getClientErrorLogPath() {
+  return join2(getLogsDir(), "client-errors.log");
+}
+function getAgentLogPath() {
+  return join2(getLogsDir(), "agent.jsonl");
+}
+function getDaemonLogPath(socketPath) {
+  const normalized = normalizeSocketPath(socketPath);
+  const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 8);
+  return join2(getLogsDir(), `${basename2(normalized)}.${hash}.log`);
+}
+function getDaemonUpdateRestartManifestPath(socketPath, agentDir = getAgentDir()) {
+  const normalizedSocketPath = normalizeSocketPath(socketPath);
+  const socketHash = createHash("sha256").update(normalizedSocketPath).digest("hex");
+  return join2(agentDir, "daemon-update-restarts", `${socketHash}.json`);
+}
+function getLegacyDaemonUpdateRestartManifestPath(agentDir = getAgentDir()) {
+  return join2(agentDir, "daemon-update-restart.json");
+}
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+function appendRotatingLog(logPath, message, maxBytes = MAX_LOG_BYTES) {
+  try {
+    mkdirSync(dirname2(logPath), { recursive: true });
+    try {
+      if (existsSync(logPath) && statSync(logPath).size > maxBytes) {
+        rmSync(`${logPath}.old`, { force: true });
+        renameSync(logPath, `${logPath}.old`);
+      }
+    } catch {
+    }
+    appendFileSync(logPath, `${message}
+`);
+  } catch {
+  }
+}
+function getAuthPath() {
+  return resolveRuntimePaths().auth;
+}
+function getCronJobsPath(agentDir = getAgentDir()) {
+  return join2(agentDir, "cron-jobs.json");
+}
+function getBinDir() {
+  return join2(getAgentDir(), "bin");
+}
+function getSessionsDir(agentDir = getAgentDir()) {
+  const envDir = getSessionDirEnvOverride();
+  if (envDir) {
+    return envDir;
+  }
+  return join2(agentDir, "sessions");
+}
+function getSessionDirEnvOverride() {
+  const envDir = readAbsolutePathEnv(PRODUCT_ENV.sessions);
+  return envDir ? assertProductStatePath(envDir) : void 0;
+}
+function getDebugLogPath() {
+  return join2(getAgentDir(), `${APP_NAME}-debug.log`);
+}
+
+// ../../node_modules/typebox/build/index.mjs
+var build_exports = {};
+__export(build_exports, {
+  AddImmutable: () => AddImmutable,
+  AddImmutableDeferred: () => AddImmutableDeferred,
+  AddOptional: () => AddOptional,
+  AddOptionalDeferred: () => AddOptionalDeferred,
+  AddReadonly: () => AddReadonly,
+  AddReadonlyDeferred: () => AddReadonlyDeferred,
+  Any: () => Any,
+  Array: () => _Array_,
+  ArrayOptions: () => ArrayOptions,
+  BigInt: () => BigInt,
+  BigIntPattern: () => BigIntPattern,
+  Boolean: () => Boolean,
+  Broaden: () => Broaden,
+  Call: () => Call,
+  CallConstruct: () => CallConstruct,
+  Capitalize: () => Capitalize,
+  CapitalizeAction: () => CapitalizeAction,
+  CapitalizeDeferred: () => CapitalizeDeferred,
+  CapitalizeInstantiate: () => CapitalizeInstantiate,
+  Codec: () => Codec,
+  CollapseToObject: () => CollapseToObject,
+  Compare: () => Compare,
+  Composite: () => Composite,
+  Conditional: () => Conditional,
+  ConditionalAction: () => ConditionalAction,
+  ConditionalDeferred: () => ConditionalDeferred,
+  ConditionalInstantiate: () => ConditionalInstantiate,
+  Constructor: () => Constructor,
+  ConstructorOptions: () => ConstructorOptions,
+  ConstructorParameters: () => ConstructorParameters,
+  ConstructorParametersAction: () => ConstructorParametersAction,
+  ConstructorParametersDeferred: () => ConstructorParametersDeferred,
+  ConstructorParametersInstantiate: () => ConstructorParametersInstantiate,
+  ConvertToIntegerKey: () => ConvertToIntegerKey,
+  Cyclic: () => Cyclic,
+  CyclicCandidates: () => CyclicCandidates,
+  CyclicCheck: () => CyclicCheck,
+  CyclicDependencies: () => CyclicDependencies,
+  CyclicExtends: () => CyclicExtends,
+  CyclicOptions: () => CyclicOptions,
+  CyclicTarget: () => CyclicTarget,
+  Decode: () => Decode,
+  DecodeBuilder: () => DecodeBuilder,
+  Deferred: () => Deferred,
+  Dependent: () => Dependent,
+  DependentOptions: () => DependentOptions,
+  Distribute: () => Distribute,
+  Encode: () => Encode,
+  EncodeBuilder: () => EncodeBuilder,
+  Enum: () => Enum,
+  Evaluate: () => Evaluate,
+  EvaluateAction: () => EvaluateAction,
+  EvaluateDeferred: () => EvaluateDeferred,
+  EvaluateDependent: () => EvaluateDependent,
+  EvaluateEnum: () => EvaluateEnum,
+  EvaluateInstantiate: () => EvaluateInstantiate,
+  EvaluateIntersect: () => EvaluateIntersect,
+  EvaluateTemplateLiteral: () => EvaluateTemplateLiteral,
+  EvaluateType: () => EvaluateType,
+  EvaluateUnion: () => EvaluateUnion,
+  EvaluateUnionFast: () => EvaluateUnionFast,
+  Exclude: () => Exclude,
+  ExcludeAction: () => ExcludeAction,
+  ExcludeDeferred: () => ExcludeDeferred,
+  ExcludeInstantiate: () => ExcludeInstantiate,
+  Extends: () => Extends,
+  ExtendsResult: () => result_exports,
+  Extract: () => Extract,
+  ExtractAction: () => ExtractAction,
+  ExtractDeferred: () => ExtractDeferred,
+  ExtractInstantiate: () => ExtractInstantiate,
+  Flatten: () => Flatten,
+  Function: () => _Function_,
+  FunctionOptions: () => FunctionOptions,
+  Generic: () => Generic,
+  Identifier: () => Identifier,
+  Immutable: () => Immutable,
+  Index: () => Index,
+  IndexAction: () => IndexAction,
+  IndexDeferred: () => IndexDeferred,
+  IndexInstantiate: () => IndexInstantiate,
+  Infer: () => Infer,
+  InstanceType: () => InstanceType,
+  InstanceTypeAction: () => InstanceTypeAction,
+  InstanceTypeDeferred: () => InstanceTypeDeferred,
+  InstanceTypeInstantiate: () => InstanceTypeInstantiate,
+  Instantiate: () => Instantiate,
+  InstantiateCyclic: () => InstantiateCyclic,
+  Integer: () => Integer,
+  IntegerKey: () => IntegerKey,
+  IntegerPattern: () => IntegerPattern,
+  Interface: () => Interface,
+  InterfaceAction: () => InterfaceAction,
+  InterfaceDeferred: () => InterfaceDeferred,
+  InterfaceInstantiate: () => InterfaceInstantiate,
+  Intersect: () => Intersect,
+  IntersectOptions: () => IntersectOptions,
+  InvalidLiteralValue: () => InvalidLiteralValue,
+  IsAny: () => IsAny,
+  IsArray: () => IsArray,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsCall: () => IsCall,
+  IsCodec: () => IsCodec,
+  IsConstructor: () => IsConstructor,
+  IsCyclic: () => IsCyclic,
+  IsDeferred: () => IsDeferred,
+  IsDependent: () => IsDependent,
+  IsEnum: () => IsEnum,
+  IsEnumValue: () => IsEnumValue,
+  IsFunction: () => IsFunction,
+  IsGeneric: () => IsGeneric,
+  IsIdentifier: () => IsIdentifier,
+  IsImmutable: () => IsImmutable,
+  IsInfer: () => IsInfer,
+  IsInteger: () => IsInteger,
+  IsInterfaceDeferred: () => IsInterfaceDeferred,
+  IsIntersect: () => IsIntersect,
+  IsKind: () => IsKind,
+  IsLiteral: () => IsLiteral,
+  IsLiteralBigInt: () => IsLiteralBigInt,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue,
+  IsNever: () => IsNever,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsOptional: () => IsOptional,
+  IsParameter: () => IsParameter,
+  IsReadonly: () => IsReadonly,
+  IsRecord: () => IsRecord,
+  IsRef: () => IsRef,
+  IsRefine: () => IsRefine,
+  IsRefinement: () => IsRefinement,
+  IsRest: () => IsRest,
+  IsSchema: () => IsSchema,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsTemplateLiteralDeferred: () => IsTemplateLiteralDeferred,
+  IsTemplateLiteralFinite: () => IsTemplateLiteralFinite,
+  IsTemplateLiteralPattern: () => IsTemplateLiteralPattern,
+  IsThis: () => IsThis,
+  IsTuple: () => IsTuple,
+  IsTypeScriptEnumLike: () => IsTypeScriptEnumLike,
+  IsUndefined: () => IsUndefined,
+  IsUnion: () => IsUnion,
+  IsUnknown: () => IsUnknown,
+  IsUnsafe: () => IsUnsafe,
+  IsVoid: () => IsVoid,
+  KeyOf: () => KeyOf,
+  KeyOfAction: () => KeyOfAction,
+  KeyOfDeferred: () => KeyOfDeferred,
+  KeyOfInstantiate: () => KeyOfInstantiate,
+  KeysToIndexer: () => KeysToIndexer,
+  Literal: () => Literal,
+  LiteralTypeName: () => LiteralTypeName,
+  Lowercase: () => Lowercase,
+  LowercaseAction: () => LowercaseAction,
+  LowercaseDeferred: () => LowercaseDeferred,
+  LowercaseInstantiate: () => LowercaseInstantiate,
+  Mapped: () => Mapped,
+  MappedAction: () => MappedAction,
+  MappedDeferred: () => MappedDeferred,
+  MappedInstantiate: () => MappedInstantiate,
+  Module: () => Module,
+  ModuleDeferred: () => ModuleDeferred,
+  ModuleInstantiate: () => ModuleInstantiate,
+  Narrow: () => Narrow,
+  Never: () => Never,
+  NeverPattern: () => NeverPattern,
+  NonNullable: () => NonNullable,
+  NonNullableAction: () => NonNullableAction,
+  NonNullableDeferred: () => NonNullableDeferred,
+  NonNullableInstantiate: () => NonNullableInstantiate,
+  Null: () => Null,
+  Number: () => Number2,
+  NumberKey: () => NumberKey,
+  NumberPattern: () => NumberPattern,
+  Object: () => _Object_,
+  ObjectOptions: () => ObjectOptions,
+  Omit: () => Omit,
+  OmitAction: () => OmitAction,
+  OmitDeferred: () => OmitDeferred,
+  OmitInstantiate: () => OmitInstantiate,
+  Optional: () => Optional,
+  Parameter: () => Parameter,
+  Parameters: () => Parameters,
+  ParametersAction: () => ParametersAction,
+  ParametersDeferred: () => ParametersDeferred,
+  ParametersInstantiate: () => ParametersInstantiate,
+  ParsePatternIntoTypes: () => ParsePatternIntoTypes,
+  ParseTemplateIntoTypes: () => ParseTemplateIntoTypes,
+  Partial: () => Partial,
+  PartialAction: () => PartialAction,
+  PartialDeferred: () => PartialDeferred,
+  PartialInstantiate: () => PartialInstantiate,
+  Pick: () => Pick,
+  PickAction: () => PickAction,
+  PickDeferred: () => PickDeferred,
+  PickInstantiate: () => PickInstantiate,
+  Priority: () => Priority,
+  PropertyKeys: () => PropertyKeys,
+  PropertyValues: () => PropertyValues,
+  Readonly: () => Readonly,
+  ReadonlyObject: () => ReadonlyObject,
+  ReadonlyObjectAction: () => ReadonlyObjectAction,
+  ReadonlyObjectDeferred: () => ReadonlyObjectDeferred,
+  ReadonlyObjectInstantiate: () => ReadonlyObjectInstantiate,
+  ReadonlyType: () => ReadonlyType,
+  Record: () => Record,
+  RecordAction: () => RecordAction,
+  RecordDeferred: () => RecordDeferred,
+  RecordFromPattern: () => RecordFromPattern,
+  RecordInstantiate: () => RecordInstantiate,
+  RecordKey: () => RecordKey,
+  RecordOptions: () => RecordOptions,
+  RecordPattern: () => RecordPattern,
+  RecordPatternToType: () => RecordPatternToType,
+  RecordValue: () => RecordValue,
+  Ref: () => Ref,
+  RefInstantiate: () => RefInstantiate,
+  Refine: () => Refine,
+  RefineAdd: () => RefineAdd,
+  RemoveImmutable: () => RemoveImmutable,
+  RemoveImmutableDeferred: () => RemoveImmutableDeferred,
+  RemoveOptional: () => RemoveOptional,
+  RemoveOptionalDeferred: () => RemoveOptionalDeferred,
+  RemoveReadonly: () => RemoveReadonly,
+  RemoveReadonlyDeferred: () => RemoveReadonlyDeferred,
+  Required: () => Required,
+  RequiredAction: () => RequiredAction,
+  RequiredArray: () => RequiredArray,
+  RequiredDeferred: () => RequiredDeferred,
+  RequiredInstantiate: () => RequiredInstantiate,
+  Rest: () => Rest,
+  ResultDisjoint: () => ResultDisjoint,
+  ResultEqual: () => ResultEqual,
+  ResultLeftInside: () => ResultLeftInside,
+  ResultRightInside: () => ResultRightInside,
+  ReturnType: () => ReturnType,
+  ReturnTypeAction: () => ReturnTypeAction,
+  ReturnTypeDeferred: () => ReturnTypeDeferred,
+  ReturnTypeInstantiate: () => ReturnTypeInstantiate,
+  Script: () => Script,
+  String: () => String2,
+  StringKey: () => StringKey,
+  StringPattern: () => StringPattern,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  TemplateLiteralCreate: () => TemplateLiteralCreate,
+  TemplateLiteralDecode: () => TemplateLiteralDecode,
+  TemplateLiteralDecodeUnsafe: () => TemplateLiteralDecodeUnsafe,
+  TemplateLiteralDeferred: () => TemplateLiteralDeferred,
+  TemplateLiteralEncode: () => TemplateLiteralEncode,
+  TemplateLiteralFromString: () => TemplateLiteralFromString,
+  TemplateLiteralFromTypes: () => TemplateLiteralFromTypes,
+  This: () => This,
+  Tuple: () => Tuple,
+  TupleOptions: () => TupleOptions,
+  Type: () => typebox_exports,
+  TypeScriptEnumToEnumValues: () => TypeScriptEnumToEnumValues,
+  Uncapitalize: () => Uncapitalize,
+  UncapitalizeAction: () => UncapitalizeAction,
+  UncapitalizeDeferred: () => UncapitalizeDeferred,
+  UncapitalizeInstantiate: () => UncapitalizeInstantiate,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  UnionOptions: () => UnionOptions,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  UppercaseAction: () => UppercaseAction,
+  UppercaseDeferred: () => UppercaseDeferred,
+  UppercaseInstantiate: () => UppercaseInstantiate,
+  Void: () => Void,
+  With: () => With,
+  WithAction: () => WithAction,
+  WithDeferred: () => WithDeferred,
+  WithInstantiate: () => WithInstantiate,
+  _Array_: () => _Array_,
+  _Function_: () => _Function_,
+  _Object_: () => _Object_,
+  default: () => build_default
+});
+
+// ../../node_modules/typebox/build/typebox.mjs
+var typebox_exports = {};
+__export(typebox_exports, {
+  Any: () => Any,
+  Array: () => _Array_,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean,
+  Call: () => Call,
+  Capitalize: () => Capitalize,
+  Codec: () => Codec,
+  Conditional: () => Conditional,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Cyclic: () => Cyclic,
+  Decode: () => Decode,
+  DecodeBuilder: () => DecodeBuilder,
+  Dependent: () => Dependent,
+  Encode: () => Encode,
+  EncodeBuilder: () => EncodeBuilder,
+  Enum: () => Enum,
+  Evaluate: () => Evaluate,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  ExtendsResult: () => result_exports,
+  Extract: () => Extract,
+  Function: () => _Function_,
+  Generic: () => Generic,
+  Identifier: () => Identifier,
+  Immutable: () => Immutable,
+  Index: () => Index,
+  Infer: () => Infer,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Interface: () => Interface,
+  Intersect: () => Intersect,
+  IsAny: () => IsAny,
+  IsArray: () => IsArray,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsCall: () => IsCall,
+  IsCodec: () => IsCodec,
+  IsConstructor: () => IsConstructor,
+  IsCyclic: () => IsCyclic,
+  IsDependent: () => IsDependent,
+  IsEnum: () => IsEnum,
+  IsEnumValue: () => IsEnumValue,
+  IsFunction: () => IsFunction,
+  IsGeneric: () => IsGeneric,
+  IsIdentifier: () => IsIdentifier,
+  IsImmutable: () => IsImmutable,
+  IsInfer: () => IsInfer,
+  IsInteger: () => IsInteger,
+  IsIntersect: () => IsIntersect,
+  IsKind: () => IsKind,
+  IsLiteral: () => IsLiteral,
+  IsNever: () => IsNever,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsOptional: () => IsOptional,
+  IsParameter: () => IsParameter,
+  IsReadonly: () => IsReadonly,
+  IsRecord: () => IsRecord,
+  IsRef: () => IsRef,
+  IsRefine: () => IsRefine,
+  IsRest: () => IsRest,
+  IsSchema: () => IsSchema,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsThis: () => IsThis,
+  IsTuple: () => IsTuple,
+  IsUndefined: () => IsUndefined,
+  IsUnion: () => IsUnion,
+  IsUnknown: () => IsUnknown,
+  IsUnsafe: () => IsUnsafe,
+  IsVoid: () => IsVoid,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  NonNullable: () => NonNullable,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => _Object_,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameter: () => Parameter,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Readonly: () => Readonly,
+  ReadonlyObject: () => ReadonlyObject,
+  ReadonlyType: () => ReadonlyType,
+  Record: () => Record,
+  RecordKey: () => RecordKey,
+  RecordPattern: () => RecordPattern,
+  RecordValue: () => RecordValue,
+  Ref: () => Ref,
+  Refine: () => Refine,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  Script: () => Script,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  This: () => This,
+  Tuple: () => Tuple,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void,
+  With: () => With
+});
+
+// ../../node_modules/typebox/build/index.mjs
+var build_default = typebox_exports;
+
+// ../ai/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AssistantMessageEventStream: () => AssistantMessageEventStream,
+  EventStream: () => EventStream,
+  RequestTokenBudget: () => RequestTokenBudget,
+  RequestTokenBudgetError: () => RequestTokenBudgetError,
+  StreamFailureError: () => StreamFailureError,
+  StringEnum: () => StringEnum,
+  Type: () => typebox_exports,
+  appendAssistantMessageDiagnostic: () => appendAssistantMessageDiagnostic,
+  assertBuiltInAttemptSupport: () => assertBuiltInAttemptSupport,
+  calculateCost: () => calculateCost,
+  clampThinkingLevel: () => clampThinkingLevel,
+  classifyStreamFailure: () => classifyStreamFailure,
+  cleanupSessionResources: () => cleanupSessionResources,
+  clearApiProviders: () => clearApiProviders,
+  complete: () => complete,
+  completeSimple: () => completeSimple,
+  createAssistantMessageDiagnostic: () => createAssistantMessageDiagnostic,
+  createAssistantMessageEventStream: () => createAssistantMessageEventStream,
+  extractDiagnosticError: () => extractDiagnosticError,
+  extractStreamFailureInfo: () => extractStreamFailureInfo,
+  fauxAssistantMessage: () => fauxAssistantMessage,
+  fauxText: () => fauxText,
+  fauxThinking: () => fauxThinking,
+  fauxToolCall: () => fauxToolCall,
+  findEnvKeys: () => findEnvKeys,
+  formatStreamFailureMessage: () => formatStreamFailureMessage,
+  formatThrownValue: () => formatThrownValue,
+  getApiProvider: () => getApiProvider,
+  getApiProviders: () => getApiProviders,
+  getEnvApiKey: () => getEnvApiKey,
+  getLogger: () => getLogger,
+  getModel: () => getModel,
+  getModels: () => getModels,
+  getProviders: () => getProviders,
+  getSupportedThinkingLevels: () => getSupportedThinkingLevels,
+  invokeRequestMeasurement: () => invokeRequestMeasurement,
+  isContextOverflow: () => isContextOverflow,
+  isLocalFauxProvider: () => isLocalFauxProvider,
+  isLocalFauxStream: () => isLocalFauxStream,
+  isLocalRequestPreparationError: () => isLocalRequestPreparationError,
+  isTransientProviderFailure: () => isTransientProviderFailure,
+  markLocalRequestPreparationError: () => markLocalRequestPreparationError,
+  matchesApiProvider: () => matchesApiProvider,
+  modelsAreEqual: () => modelsAreEqual,
+  parseJsonWithRepair: () => parseJsonWithRepair,
+  parseStreamingJson: () => parseStreamingJson,
+  recordStreamFailure: () => recordStreamFailure,
+  registerApiProvider: () => registerApiProvider,
+  registerBuiltInApiProviders: () => registerBuiltInApiProviders,
+  registerFauxProvider: () => registerFauxProvider,
+  registerSessionResourceCleanup: () => registerSessionResourceCleanup,
+  repairJson: () => repairJson,
+  requestTokenRouteIdentity: () => requestTokenRouteIdentity,
+  resetApiProviders: () => resetApiProviders,
+  setBedrockProviderModule: () => setBedrockProviderModule,
+  setLogSink: () => setLogSink,
+  stream: () => stream,
+  streamAnthropic: () => streamAnthropic,
+  streamAzureOpenAIResponses: () => streamAzureOpenAIResponses,
+  streamFailureFromStopReason: () => streamFailureFromStopReason,
+  streamFailureMessage: () => streamFailureMessage,
+  streamGoogle: () => streamGoogle,
+  streamGoogleVertex: () => streamGoogleVertex,
+  streamMistral: () => streamMistral,
+  streamOpenAICodexResponses: () => streamOpenAICodexResponses,
+  streamOpenAICompletions: () => streamOpenAICompletions,
+  streamOpenAIResponses: () => streamOpenAIResponses,
+  streamSimple: () => streamSimple,
+  streamSimpleAnthropic: () => streamSimpleAnthropic,
+  streamSimpleAzureOpenAIResponses: () => streamSimpleAzureOpenAIResponses,
+  streamSimpleGoogle: () => streamSimpleGoogle,
+  streamSimpleGoogleVertex: () => streamSimpleGoogleVertex,
+  streamSimpleMistral: () => streamSimpleMistral,
+  streamSimpleOpenAICodexResponses: () => streamSimpleOpenAICodexResponses,
+  streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions,
+  streamSimpleOpenAIResponses: () => streamSimpleOpenAIResponses,
+  stringifyLogEntry: () => stringifyLogEntry,
+  supportsFastMode: () => supportsFastMode,
+  truncateRawPayload: () => truncateRawPayload,
+  unregisterApiProviders: () => unregisterApiProviders,
+  validateToolArguments: () => validateToolArguments,
+  validateToolCall: () => validateToolCall,
+  withRequestBody: () => withRequestBody
+});
+
+// ../ai/src/api-registry.ts
+var apiProviderRegistry = /* @__PURE__ */ new Map();
+function wrapStream(api, stream2) {
+  return (model, context, options) => {
+    if (model.api !== api) {
+      throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+    }
+    return stream2(model, context, options);
+  };
+}
+function wrapStreamSimple(api, streamSimple2) {
+  return (model, context, options) => {
+    if (model.api !== api) {
+      throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+    }
+    return streamSimple2(model, context, options);
+  };
+}
+function registerApiProvider(provider, sourceId) {
+  const stream2 = wrapStream(provider.api, provider.stream);
+  const streamSimple2 = wrapStreamSimple(provider.api, provider.streamSimple);
+  apiProviderRegistry.set(provider.api, {
+    provider: { api: provider.api, stream: stream2, streamSimple: streamSimple2 },
+    sourceId,
+    originalStream: provider.stream,
+    originalStreamSimple: provider.streamSimple,
+    registeredStream: stream2,
+    registeredStreamSimple: streamSimple2
+  });
+}
+function getApiProvider(api) {
+  return apiProviderRegistry.get(api)?.provider;
+}
+function matchesApiProvider(api, stream2, streamSimple2) {
+  const entry = apiProviderRegistry.get(api);
+  return !!entry && entry.originalStream === stream2 && entry.originalStreamSimple === streamSimple2 && entry.provider.stream === entry.registeredStream && entry.provider.streamSimple === entry.registeredStreamSimple;
+}
+function getApiProviders() {
+  return Array.from(apiProviderRegistry.values(), (entry) => entry.provider);
+}
+function unregisterApiProviders(sourceId) {
+  for (const [api, entry] of apiProviderRegistry.entries()) {
+    if (entry.sourceId === sourceId) {
+      apiProviderRegistry.delete(api);
+    }
+  }
+}
+function clearApiProviders() {
+  apiProviderRegistry.clear();
+}
+
+// ../ai/src/providers/faux.ts
+var DEFAULT_API = "faux";
+var DEFAULT_PROVIDER = "faux";
+var DEFAULT_MODEL_ID = "faux-1";
+var DEFAULT_MODEL_NAME = "Faux Model";
+var DEFAULT_BASE_URL = "http://localhost:0";
+var DEFAULT_MIN_TOKEN_SIZE = 3;
+var DEFAULT_MAX_TOKEN_SIZE = 5;
+var localImplementations = /* @__PURE__ */ new Map();
+var localStreams = /* @__PURE__ */ new WeakSet();
+function isLocalFauxProvider(api) {
+  const implementation = localImplementations.get(api);
+  return !!implementation && matchesApiProvider(api, implementation.stream, implementation.streamSimple);
+}
+function isLocalFauxStream(stream2) {
+  return localStreams.has(stream2);
+}
+var DEFAULT_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+};
+function fauxText(text) {
+  return { type: "text", text };
+}
+function fauxThinking(thinking) {
+  return { type: "thinking", thinking };
+}
+function fauxToolCall(name, arguments_, options = {}) {
+  return {
+    type: "toolCall",
+    id: options.id ?? randomId("tool"),
+    name,
+    arguments: arguments_
+  };
+}
+function normalizeFauxAssistantContent(content) {
+  if (typeof content === "string") {
+    return [fauxText(content)];
+  }
+  return Array.isArray(content) ? content : [content];
+}
+function fauxAssistantMessage(content, options = {}) {
+  return {
+    role: "assistant",
+    content: normalizeFauxAssistantContent(content),
+    api: DEFAULT_API,
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL_ID,
+    usage: DEFAULT_USAGE,
+    stopReason: options.stopReason ?? "stop",
+    errorMessage: options.errorMessage,
+    responseId: options.responseId,
+    timestamp: options.timestamp ?? Date.now()
+  };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function randomId(prefix) {
+  return `${prefix}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+}
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((block) => {
+    if (block.type === "text") {
+      return block.text;
+    }
+    return `[image:${block.mimeType}:${block.data.length}]`;
+  }).join("\n");
+}
+function assistantContentToText(content) {
+  return content.map((block) => {
+    if (block.type === "text") {
+      return block.text;
+    }
+    if (block.type === "thinking") {
+      return block.thinking;
+    }
+    return `${block.name}:${JSON.stringify(block.arguments)}`;
+  }).join("\n");
+}
+function toolResultToText(message) {
+  return [message.toolName, ...message.content.map((block) => contentToText([block]))].join("\n");
+}
+function messageToText(message) {
+  if (message.role === "user") {
+    return contentToText(message.content);
+  }
+  if (message.role === "assistant") {
+    return assistantContentToText(message.content);
+  }
+  return toolResultToText(message);
+}
+function serializeContext(context) {
+  const parts = [];
+  if (context.systemPrompt) {
+    parts.push(`system:${context.systemPrompt}`);
+  }
+  for (const message of context.messages) {
+    parts.push(`${message.role}:${messageToText(message)}`);
+  }
+  if (context.tools?.length) {
+    parts.push(`tools:${JSON.stringify(context.tools)}`);
+  }
+  return parts.join("\n\n");
+}
+function commonPrefixLength(a, b) {
+  const length = Math.min(a.length, b.length);
+  let index = 0;
+  while (index < length && a[index] === b[index]) {
+    index++;
+  }
+  return index;
+}
+function withUsageEstimate(message, context, options, promptCache) {
+  const promptText = serializeContext(context);
+  const promptTokens = estimateTokens(promptText);
+  const outputTokens = estimateTokens(assistantContentToText(message.content));
+  let input = promptTokens;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  const sessionId = options?.sessionId;
+  if (sessionId && options?.cacheRetention !== "none") {
+    const previousPrompt = promptCache.get(sessionId);
+    if (previousPrompt) {
+      const cachedChars = commonPrefixLength(previousPrompt, promptText);
+      cacheRead = estimateTokens(previousPrompt.slice(0, cachedChars));
+      cacheWrite = estimateTokens(promptText.slice(cachedChars));
+      input = Math.max(0, promptTokens - cacheRead);
+    } else {
+      cacheWrite = promptTokens;
+    }
+    promptCache.set(sessionId, promptText);
+  }
+  return {
+    ...message,
+    usage: {
+      input,
+      output: outputTokens,
+      cacheRead,
+      cacheWrite,
+      totalTokens: input + outputTokens + cacheRead + cacheWrite,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    }
+  };
+}
+function splitStringByTokenSize(text, minTokenSize, maxTokenSize) {
+  const chunks = [];
+  let index = 0;
+  while (index < text.length) {
+    const tokenSize = minTokenSize + Math.floor(Math.random() * (maxTokenSize - minTokenSize + 1));
+    const charSize = Math.max(1, tokenSize * 4);
+    chunks.push(text.slice(index, index + charSize));
+    index += charSize;
+  }
+  return chunks.length > 0 ? chunks : [""];
+}
+function cloneMessage(message, api, provider, modelId) {
+  const cloned = structuredClone(message);
+  return {
+    ...cloned,
+    api,
+    provider,
+    model: modelId,
+    timestamp: cloned.timestamp ?? Date.now(),
+    usage: cloned.usage ?? DEFAULT_USAGE
+  };
+}
+function createErrorMessage(error, api, provider, modelId) {
+  return {
+    role: "assistant",
+    content: [],
+    api,
+    provider,
+    model: modelId,
+    usage: DEFAULT_USAGE,
+    stopReason: "error",
+    errorMessage: error instanceof Error ? error.message : String(error),
+    timestamp: Date.now()
+  };
+}
+function createAbortedMessage(partial) {
+  return {
+    ...partial,
+    stopReason: "aborted",
+    errorMessage: "Request was aborted",
+    timestamp: Date.now()
+  };
+}
+function scheduleChunk(chunk, tokensPerSecond) {
+  if (!tokensPerSecond || tokensPerSecond <= 0) {
+    return new Promise((resolve4) => queueMicrotask(resolve4));
+  }
+  const delayMs = estimateTokens(chunk) / tokensPerSecond * 1e3;
+  return new Promise((resolve4) => setTimeout(resolve4, delayMs));
+}
+async function streamWithDeltas(stream2, message, minTokenSize, maxTokenSize, tokensPerSecond, signal) {
+  const partial = { ...message, content: [] };
+  if (signal?.aborted) {
+    const aborted = createAbortedMessage(partial);
+    stream2.push({ type: "error", reason: "aborted", error: aborted });
+    stream2.end(aborted);
+    return;
+  }
+  stream2.push({ type: "start", partial: { ...partial } });
+  for (let index = 0; index < message.content.length; index++) {
+    if (signal?.aborted) {
+      const aborted = createAbortedMessage(partial);
+      stream2.push({ type: "error", reason: "aborted", error: aborted });
+      stream2.end(aborted);
+      return;
+    }
+    const block = message.content[index];
+    if (block.type === "thinking") {
+      partial.content = [...partial.content, { type: "thinking", thinking: "" }];
+      stream2.push({ type: "thinking_start", contentIndex: index, partial: { ...partial } });
+      for (const chunk of splitStringByTokenSize(block.thinking, minTokenSize, maxTokenSize)) {
+        await scheduleChunk(chunk, tokensPerSecond);
+        if (signal?.aborted) {
+          const aborted = createAbortedMessage(partial);
+          stream2.push({ type: "error", reason: "aborted", error: aborted });
+          stream2.end(aborted);
+          return;
+        }
+        partial.content[index].thinking += chunk;
+        stream2.push({ type: "thinking_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
+      }
+      stream2.push({
+        type: "thinking_end",
+        contentIndex: index,
+        content: block.thinking,
+        partial: { ...partial }
+      });
+      continue;
+    }
+    if (block.type === "text") {
+      partial.content = [...partial.content, { type: "text", text: "" }];
+      stream2.push({ type: "text_start", contentIndex: index, partial: { ...partial } });
+      for (const chunk of splitStringByTokenSize(block.text, minTokenSize, maxTokenSize)) {
+        await scheduleChunk(chunk, tokensPerSecond);
+        if (signal?.aborted) {
+          const aborted = createAbortedMessage(partial);
+          stream2.push({ type: "error", reason: "aborted", error: aborted });
+          stream2.end(aborted);
+          return;
+        }
+        partial.content[index].text += chunk;
+        stream2.push({ type: "text_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
+      }
+      stream2.push({ type: "text_end", contentIndex: index, content: block.text, partial: { ...partial } });
+      continue;
+    }
+    partial.content = [...partial.content, { type: "toolCall", id: block.id, name: block.name, arguments: {} }];
+    stream2.push({ type: "toolcall_start", contentIndex: index, partial: { ...partial } });
+    for (const chunk of splitStringByTokenSize(JSON.stringify(block.arguments), minTokenSize, maxTokenSize)) {
+      await scheduleChunk(chunk, tokensPerSecond);
+      if (signal?.aborted) {
+        const aborted = createAbortedMessage(partial);
+        stream2.push({ type: "error", reason: "aborted", error: aborted });
+        stream2.end(aborted);
+        return;
+      }
+      stream2.push({ type: "toolcall_delta", contentIndex: index, delta: chunk, partial: { ...partial } });
+    }
+    partial.content[index].arguments = block.arguments;
+    stream2.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: { ...partial } });
+  }
+  if (message.stopReason === "error" || message.stopReason === "aborted") {
+    stream2.push({ type: "error", reason: message.stopReason, error: message });
+    stream2.end(message);
+    return;
+  }
+  stream2.push({ type: "done", reason: message.stopReason, message });
+  stream2.end(message);
+}
+function registerFauxProvider(options = {}) {
+  const api = options.api ?? randomId(DEFAULT_API);
+  const provider = options.provider ?? DEFAULT_PROVIDER;
+  const sourceId = randomId("faux-provider");
+  const minTokenSize = Math.max(
+    1,
+    Math.min(options.tokenSize?.min ?? DEFAULT_MIN_TOKEN_SIZE, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE)
+  );
+  const maxTokenSize = Math.max(minTokenSize, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE);
+  let pendingResponses = [];
+  const tokensPerSecond = options.tokensPerSecond;
+  const state = { callCount: 0 };
+  const promptCache = /* @__PURE__ */ new Map();
+  const modelDefinitions = options.models?.length ? options.models : [
+    {
+      id: DEFAULT_MODEL_ID,
+      name: DEFAULT_MODEL_NAME,
+      reasoning: false,
+      input: ["text", "image"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128e3,
+      maxTokens: 16384
+    }
+  ];
+  const models = modelDefinitions.map((definition) => ({
+    id: definition.id,
+    name: definition.name ?? definition.id,
+    api,
+    provider,
+    baseUrl: DEFAULT_BASE_URL,
+    reasoning: definition.reasoning ?? false,
+    input: definition.input ?? ["text", "image"],
+    cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: definition.contextWindow ?? 128e3,
+    maxTokens: definition.maxTokens ?? 16384
+  }));
+  const stream2 = (requestModel, context, streamOptions) => {
+    streamOptions = streamOptions ? { ...streamOptions, attempts: void 0 } : void 0;
+    const outer = createAssistantMessageEventStream();
+    localStreams.add(outer);
+    const step = pendingResponses.shift();
+    state.callCount++;
+    queueMicrotask(async () => {
+      try {
+        await streamOptions?.onResponse?.({ status: 200, headers: {} }, requestModel);
+        if (!step) {
+          let message2 = createErrorMessage(
+            new Error("No more faux responses queued"),
+            api,
+            provider,
+            requestModel.id
+          );
+          message2 = withUsageEstimate(message2, context, streamOptions, promptCache);
+          outer.push({ type: "error", reason: "error", error: message2 });
+          outer.end(message2);
+          return;
+        }
+        const resolved = typeof step === "function" ? await step(context, streamOptions, state, requestModel) : step;
+        let message = cloneMessage(resolved, api, provider, requestModel.id);
+        message = withUsageEstimate(message, context, streamOptions, promptCache);
+        await streamWithDeltas(outer, message, minTokenSize, maxTokenSize, tokensPerSecond, streamOptions?.signal);
+      } catch (error) {
+        const message = createErrorMessage(error, api, provider, requestModel.id);
+        outer.push({ type: "error", reason: "error", error: message });
+        outer.end(message);
+      }
+    });
+    return outer;
+  };
+  const streamSimple2 = (streamModel, context, streamOptions) => stream2(streamModel, context, streamOptions);
+  const implementation = { stream: stream2, streamSimple: streamSimple2 };
+  localImplementations.set(api, implementation);
+  registerApiProvider({ api, stream: stream2, streamSimple: streamSimple2 }, sourceId);
+  function getModel2(requestedModelId) {
+    if (!requestedModelId) {
+      return models[0];
+    }
+    return models.find((candidate) => candidate.id === requestedModelId);
+  }
+  return {
+    api,
+    models,
+    getModel: getModel2,
+    state,
+    setResponses(responses) {
+      pendingResponses = [...responses];
+    },
+    appendResponses(responses) {
+      pendingResponses.push(...responses);
+    },
+    getPendingResponseCount() {
+      return pendingResponses.length;
+    },
+    unregister() {
+      unregisterApiProviders(sourceId);
+      if (localImplementations.get(api) === implementation) localImplementations.delete(api);
+    }
+  };
+}
+
+// ../ai/src/utils/native-bedrock-provider.ts
+var native;
+function isNativeBedrockProvider(stream2, streamSimple2) {
+  return native?.stream === stream2 && native.streamSimple === streamSimple2;
+}
+
+// ../ai/src/providers/register-builtins.ts
+var importNodeOnlyProvider = (specifier) => import(specifier);
+var anthropicProviderModulePromise;
+var azureOpenAIResponsesProviderModulePromise;
+var googleProviderModulePromise;
+var googleVertexProviderModulePromise;
+var mistralProviderModulePromise;
+var openAICodexResponsesProviderModulePromise;
+var openAICompletionsProviderModulePromise;
+var openAIResponsesProviderModulePromise;
+var bedrockProviderModuleOverride;
+var bedrockProviderModulePromise;
+function setBedrockProviderModule(module) {
+  bedrockProviderModuleOverride = {
+    stream: module.streamBedrock,
+    streamSimple: module.streamSimpleBedrock
+  };
+}
+function forwardStream(target, source) {
+  (async () => {
+    for await (const event of source) {
+      target.push(event);
+    }
+    target.end();
+  })();
+}
+function createLazyLoadErrorMessage(model, error) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason: "error",
+    errorMessage: error instanceof Error ? error.message : String(error),
+    timestamp: Date.now()
+  };
+}
+function createLazyStream(loadModule) {
+  return (model, context, options) => {
+    const outer = new AssistantMessageEventStream();
+    loadModule().then((module) => {
+      if (options?.requireProviderAttempts) {
+        assertBuiltInAttemptSupport(model.api);
+        if (model.api === "bedrock-converse-stream" && !isNativeBedrockProvider(module.stream, module.streamSimple)) {
+          throw new Error(
+            "Native Bedrock inference requires the instrumented built-in provider module; custom module coverage is unestablished."
+          );
+        }
+      }
+      const inner = module.stream(model, context, options);
+      forwardStream(outer, inner);
+    }).catch((error) => {
+      const message = createLazyLoadErrorMessage(model, error);
+      outer.push({ type: "error", reason: "error", error: message });
+      outer.end(message);
+    });
+    return outer;
+  };
+}
+function createLazySimpleStream(loadModule) {
+  return (model, context, options) => {
+    const outer = new AssistantMessageEventStream();
+    loadModule().then((module) => {
+      if (options?.requireProviderAttempts) {
+        assertBuiltInAttemptSupport(model.api);
+        if (model.api === "bedrock-converse-stream" && !isNativeBedrockProvider(module.stream, module.streamSimple)) {
+          throw new Error(
+            "Native Bedrock inference requires the instrumented built-in provider module; custom module coverage is unestablished."
+          );
+        }
+      }
+      const inner = module.streamSimple(model, context, options);
+      forwardStream(outer, inner);
+    }).catch((error) => {
+      const message = createLazyLoadErrorMessage(model, error);
+      outer.push({ type: "error", reason: "error", error: message });
+      outer.end(message);
+    });
+    return outer;
+  };
+}
+function loadAnthropicProviderModule() {
+  anthropicProviderModulePromise ||= import("./anthropic-UV5GZDGU.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamAnthropic,
+      streamSimple: provider.streamSimpleAnthropic
+    };
+  });
+  return anthropicProviderModulePromise;
+}
+function loadAzureOpenAIResponsesProviderModule() {
+  azureOpenAIResponsesProviderModulePromise ||= import("./azure-openai-responses-WSNPXLYC.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamAzureOpenAIResponses,
+      streamSimple: provider.streamSimpleAzureOpenAIResponses
+    };
+  });
+  return azureOpenAIResponsesProviderModulePromise;
+}
+function loadGoogleProviderModule() {
+  googleProviderModulePromise ||= import("./google-T32FMD4G.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamGoogle,
+      streamSimple: provider.streamSimpleGoogle
+    };
+  });
+  return googleProviderModulePromise;
+}
+function loadGoogleVertexProviderModule() {
+  googleVertexProviderModulePromise ||= import("./google-vertex-56KP6I3B.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamGoogleVertex,
+      streamSimple: provider.streamSimpleGoogleVertex
+    };
+  });
+  return googleVertexProviderModulePromise;
+}
+function loadMistralProviderModule() {
+  mistralProviderModulePromise ||= import("./mistral-WGBMYIVU.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamMistral,
+      streamSimple: provider.streamSimpleMistral
+    };
+  });
+  return mistralProviderModulePromise;
+}
+function loadOpenAICodexResponsesProviderModule() {
+  openAICodexResponsesProviderModulePromise ||= import("./openai-codex-responses-PIV2RQ3G.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamOpenAICodexResponses,
+      streamSimple: provider.streamSimpleOpenAICodexResponses
+    };
+  });
+  return openAICodexResponsesProviderModulePromise;
+}
+function loadOpenAICompletionsProviderModule() {
+  openAICompletionsProviderModulePromise ||= import("./openai-completions-64C3JPR4.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamOpenAICompletions,
+      streamSimple: provider.streamSimpleOpenAICompletions
+    };
+  });
+  return openAICompletionsProviderModulePromise;
+}
+function loadOpenAIResponsesProviderModule() {
+  openAIResponsesProviderModulePromise ||= import("./openai-responses-UI7RSTDV.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamOpenAIResponses,
+      streamSimple: provider.streamSimpleOpenAIResponses
+    };
+  });
+  return openAIResponsesProviderModulePromise;
+}
+function loadBedrockProviderModule() {
+  if (bedrockProviderModuleOverride) {
+    return Promise.resolve(bedrockProviderModuleOverride);
+  }
+  bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock.js").then((module) => {
+    const provider = module;
+    return {
+      stream: provider.streamBedrock,
+      streamSimple: provider.streamSimpleBedrock
+    };
+  });
+  return bedrockProviderModulePromise;
+}
+var streamAnthropic = createLazyStream(loadAnthropicProviderModule);
+var streamSimpleAnthropic = createLazySimpleStream(loadAnthropicProviderModule);
+var streamAzureOpenAIResponses = createLazyStream(loadAzureOpenAIResponsesProviderModule);
+var streamSimpleAzureOpenAIResponses = createLazySimpleStream(loadAzureOpenAIResponsesProviderModule);
+var streamGoogle = createLazyStream(loadGoogleProviderModule);
+var streamSimpleGoogle = createLazySimpleStream(loadGoogleProviderModule);
+var streamGoogleVertex = createLazyStream(loadGoogleVertexProviderModule);
+var streamSimpleGoogleVertex = createLazySimpleStream(loadGoogleVertexProviderModule);
+var streamMistral = createLazyStream(loadMistralProviderModule);
+var streamSimpleMistral = createLazySimpleStream(loadMistralProviderModule);
+var streamOpenAICodexResponses = createLazyStream(loadOpenAICodexResponsesProviderModule);
+var streamSimpleOpenAICodexResponses = createLazySimpleStream(loadOpenAICodexResponsesProviderModule);
+var streamOpenAICompletions = createLazyStream(loadOpenAICompletionsProviderModule);
+var streamSimpleOpenAICompletions = createLazySimpleStream(loadOpenAICompletionsProviderModule);
+var streamOpenAIResponses = createLazyStream(loadOpenAIResponsesProviderModule);
+var streamSimpleOpenAIResponses = createLazySimpleStream(loadOpenAIResponsesProviderModule);
+var streamBedrockLazy = createLazyStream(loadBedrockProviderModule);
+var streamSimpleBedrockLazy = createLazySimpleStream(loadBedrockProviderModule);
+var builtInImplementations = /* @__PURE__ */ new Map();
+function registerBuiltIn(provider) {
+  builtInImplementations.set(provider.api, { stream: provider.stream, streamSimple: provider.streamSimple });
+  registerApiProvider(provider);
+}
+function assertBuiltInAttemptSupport(api) {
+  if (isLocalFauxProvider(api)) return "local-faux";
+  const known = builtInImplementations.get(api);
+  if (!known || !matchesApiProvider(api, known.stream, known.streamSimple) || api === "bedrock-converse-stream" && bedrockProviderModuleOverride && !isNativeBedrockProvider(bedrockProviderModuleOverride.stream, bedrockProviderModuleOverride.streamSimple)) {
+    throw new Error(
+      "Native inference cannot admit this custom or proxy adapter: physical-attempt coverage is unestablished. Use an instrumented built-in API route such as openai-responses, openai-completions, or anthropic-messages; custom model IDs and base URLs are supported."
+    );
+  }
+  return "provider";
+}
+function registerBuiltInApiProviders() {
+  registerBuiltIn({
+    api: "anthropic-messages",
+    stream: streamAnthropic,
+    streamSimple: streamSimpleAnthropic
+  });
+  registerBuiltIn({
+    api: "openai-completions",
+    stream: streamOpenAICompletions,
+    streamSimple: streamSimpleOpenAICompletions
+  });
+  registerBuiltIn({
+    api: "mistral-conversations",
+    stream: streamMistral,
+    streamSimple: streamSimpleMistral
+  });
+  registerBuiltIn({
+    api: "openai-responses",
+    stream: streamOpenAIResponses,
+    streamSimple: streamSimpleOpenAIResponses
+  });
+  registerBuiltIn({
+    api: "azure-openai-responses",
+    stream: streamAzureOpenAIResponses,
+    streamSimple: streamSimpleAzureOpenAIResponses
+  });
+  registerBuiltIn({
+    api: "openai-codex-responses",
+    stream: streamOpenAICodexResponses,
+    streamSimple: streamSimpleOpenAICodexResponses
+  });
+  registerBuiltIn({
+    api: "google-generative-ai",
+    stream: streamGoogle,
+    streamSimple: streamSimpleGoogle
+  });
+  registerBuiltIn({
+    api: "google-vertex",
+    stream: streamGoogleVertex,
+    streamSimple: streamSimpleGoogleVertex
+  });
+  registerBuiltIn({
+    api: "bedrock-converse-stream",
+    stream: streamBedrockLazy,
+    streamSimple: streamSimpleBedrockLazy
+  });
+}
+function resetApiProviders() {
+  clearApiProviders();
+  registerBuiltInApiProviders();
+}
+registerBuiltInApiProviders();
+
+// ../ai/src/stream.ts
+function resolveApiProvider(api, options) {
+  let localSimulation = false;
+  if (options?.requireProviderAttempts) {
+    localSimulation = assertBuiltInAttemptSupport(api) === "local-faux";
+    if (!localSimulation && !options.attempts) {
+      throw new Error("Native inference requires physical-attempt admission and settlement");
+    }
+  }
+  const provider = getApiProvider(api);
+  if (!provider) throw new Error(`No API provider registered for api: ${api}`);
+  return { stream: provider.stream, streamSimple: provider.streamSimple, localSimulation };
+}
+function stream(model, context, options) {
+  const provider = resolveApiProvider(model.api, options);
+  const dispatchOptions = provider.localSimulation ? { ...options, attempts: void 0 } : options;
+  return provider.stream(model, context, dispatchOptions);
+}
+async function complete(model, context, options) {
+  const s = stream(model, context, options);
+  return s.result();
+}
+function streamSimple(model, context, options) {
+  const provider = resolveApiProvider(model.api, options);
+  const dispatchOptions = provider.localSimulation ? { ...options, attempts: void 0 } : options;
+  return provider.streamSimple(model, context, dispatchOptions);
+}
+async function completeSimple(model, context, options) {
+  const s = streamSimple(model, context, options);
+  return s.result();
+}
+
+// ../ai/src/utils/overflow.ts
+var OVERFLOW_PATTERNS = [
+  /prompt is too long/i,
+  // Anthropic token overflow
+  /request_too_large/i,
+  // Anthropic request byte-size overflow (HTTP 413)
+  /input is too long for requested model/i,
+  // Amazon Bedrock
+  /exceeds the context window/i,
+  // OpenAI (Completions & Responses API)
+  /input token count.*exceeds the maximum/i,
+  // Google (Gemini)
+  /maximum prompt length is \d+/i,
+  // xAI (Grok)
+  /reduce the length of the messages/i,
+  // Groq
+  /maximum context length is \d+ tokens/i,
+  // OpenRouter (all backends)
+  /exceeds the model's maximum context length/i,
+  // LiteLLM (input + requested output)
+  /exceeds the limit of \d+/i,
+  // GitHub Copilot
+  /exceeds the available context size/i,
+  // llama.cpp server
+  /greater than the context length/i,
+  // LM Studio
+  /context window exceeds limit/i,
+  // MiniMax
+  /exceeded model token limit/i,
+  // Kimi For Coding
+  /too large for model with \d+ maximum context length/i,
+  // Mistral
+  /model_context_window_exceeded/i,
+  // z.ai non-standard finish_reason surfaced as error text
+  /prompt too long; exceeded (?:max )?context length/i,
+  // Ollama explicit overflow error
+  /context[_ ]length[_ ]exceeded/i,
+  // Generic fallback
+  /too many tokens/i,
+  // Generic fallback
+  /token limit exceeded/i,
+  // Generic fallback
+  /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i
+  // Cerebras: 400/413 with no body
+];
+var NON_OVERFLOW_PATTERNS = [
+  /^(Throttling error|Service unavailable):/i,
+  // AWS Bedrock non-overflow errors (human-readable prefixes from formatBedrockError)
+  /rate limit/i,
+  // Generic rate limiting
+  /too many requests/i
+  // Generic HTTP 429 style
+];
+function isContextOverflow(message, contextWindow) {
+  if (message.stopReason === "error" && message.errorMessage) {
+    const isNonOverflow = NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage));
+    if (!isNonOverflow && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) {
+      return true;
+    }
+  }
+  if (contextWindow && message.stopReason === "stop") {
+    const inputTokens = message.usage.input + message.usage.cacheRead;
+    if (inputTokens > contextWindow) {
+      return true;
+    }
+  }
+  if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
+    const inputTokens = message.usage.input + message.usage.cacheRead;
+    if (inputTokens >= contextWindow * 0.99) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../ai/src/utils/typebox-helpers.ts
+function StringEnum(values, options) {
+  return typebox_exports.Unsafe({
+    type: "string",
+    enum: values,
+    ...options?.description && { description: options.description },
+    ...options?.default && { default: options.default }
+  });
+}
+
+// ../ai/src/utils/validation.ts
+var validatorCache = /* @__PURE__ */ new WeakMap();
+var TYPEBOX_KIND = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonSchemaObject(value) {
+  return isRecord(value);
+}
+function hasTypeBoxMetadata(schema) {
+  return isRecord(schema) && Object.getOwnPropertySymbols(schema).includes(TYPEBOX_KIND);
+}
+function getSchemaTypes(schema) {
+  if (typeof schema.type === "string") {
+    return [schema.type];
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.filter((type) => typeof type === "string");
+  }
+  return [];
+}
+function matchesJsonType(value, type) {
+  switch (type) {
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "string":
+      return typeof value === "string";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isRecord(value) && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+function isValidatorSchema(value) {
+  return isRecord(value);
+}
+function getSubSchemaValidator(schema) {
+  if (!isValidatorSchema(schema)) {
+    return void 0;
+  }
+  try {
+    return getValidator(schema);
+  } catch {
+    return void 0;
+  }
+}
+function coercePrimitiveByType(value, type) {
+  switch (type) {
+    case "number": {
+      if (value === null) {
+        return 0;
+      }
+      if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+          return parsed;
+        }
+      }
+      if (typeof value === "boolean") {
+        return value ? 1 : 0;
+      }
+      return value;
+    }
+    case "integer": {
+      if (value === null) {
+        return 0;
+      }
+      if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isInteger(parsed)) {
+          return parsed;
+        }
+      }
+      if (typeof value === "boolean") {
+        return value ? 1 : 0;
+      }
+      return value;
+    }
+    case "boolean": {
+      if (value === null) {
+        return false;
+      }
+      if (typeof value === "string") {
+        if (value === "true") {
+          return true;
+        }
+        if (value === "false") {
+          return false;
+        }
+      }
+      if (typeof value === "number") {
+        if (value === 1) {
+          return true;
+        }
+        if (value === 0) {
+          return false;
+        }
+      }
+      return value;
+    }
+    case "string": {
+      if (value === null) {
+        return "";
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+      return value;
+    }
+    case "null": {
+      if (value === "" || value === 0 || value === false) {
+        return null;
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function applySchemaObjectCoercion(value, schema) {
+  const properties = schema.properties;
+  const definedKeys = new Set(properties ? Object.keys(properties) : []);
+  if (properties) {
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (!(key in value)) {
+        continue;
+      }
+      value[key] = coerceWithJsonSchema(value[key], propertySchema);
+    }
+  }
+  if (schema.additionalProperties && isJsonSchemaObject(schema.additionalProperties)) {
+    for (const [key, propertyValue] of Object.entries(value)) {
+      if (definedKeys.has(key)) {
+        continue;
+      }
+      value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
+    }
+  }
+}
+function applySchemaArrayCoercion(value, schema) {
+  if (Array.isArray(schema.items)) {
+    for (let index = 0; index < value.length; index++) {
+      const itemSchema = schema.items[index];
+      if (!itemSchema) {
+        continue;
+      }
+      value[index] = coerceWithJsonSchema(value[index], itemSchema);
+    }
+    return;
+  }
+  if (isJsonSchemaObject(schema.items)) {
+    for (let index = 0; index < value.length; index++) {
+      value[index] = coerceWithJsonSchema(value[index], schema.items);
+    }
+  }
+}
+function coerceWithUnionSchema(value, schemas) {
+  for (const schema of schemas) {
+    const candidate = structuredClone(value);
+    const coerced = coerceWithJsonSchema(candidate, schema);
+    const validator = getSubSchemaValidator(schema);
+    if (validator?.Check(coerced)) {
+      return coerced;
+    }
+  }
+  return value;
+}
+function coerceWithJsonSchema(value, schema) {
+  let nextValue = value;
+  if (Array.isArray(schema.allOf)) {
+    for (const nested of schema.allOf) {
+      nextValue = coerceWithJsonSchema(nextValue, nested);
+    }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
+  }
+  if (Array.isArray(schema.oneOf)) {
+    nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
+  }
+  const schemaTypes = getSchemaTypes(schema);
+  const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+  if (schemaTypes.length > 0 && !matchesUnionMember) {
+    for (const schemaType of schemaTypes) {
+      const candidate = coercePrimitiveByType(nextValue, schemaType);
+      if (candidate !== nextValue) {
+        nextValue = candidate;
+        break;
+      }
+    }
+  }
+  if (schemaTypes.includes("object") && isRecord(nextValue) && !Array.isArray(nextValue)) {
+    applySchemaObjectCoercion(nextValue, schema);
+  }
+  if (schemaTypes.includes("array") && Array.isArray(nextValue)) {
+    applySchemaArrayCoercion(nextValue, schema);
+  }
+  return nextValue;
+}
+function getValidator(schema) {
+  const key = schema;
+  const cached = validatorCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const validator = Compile(schema);
+  validatorCache.set(key, validator);
+  return validator;
+}
+function formatValidationPath(error) {
+  if (error.keyword === "required") {
+    const requiredProperties = error.params.requiredProperties;
+    const requiredProperty = requiredProperties?.[0];
+    if (requiredProperty) {
+      const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+      return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+    }
+  }
+  const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+  return path || "root";
+}
+function validateToolCall(tools, toolCall) {
+  const tool = tools.find((t) => t.name === toolCall.name);
+  if (!tool) {
+    throw new Error(`Tool "${toolCall.name}" not found`);
+  }
+  return validateToolArguments(tool, toolCall);
+}
+function validateToolArguments(tool, toolCall) {
+  const args = structuredClone(toolCall.arguments);
+  value_exports.Convert(tool.parameters, args);
+  const validator = getValidator(tool.parameters);
+  if (!hasTypeBoxMetadata(tool.parameters) && isJsonSchemaObject(tool.parameters)) {
+    const coerced = coerceWithJsonSchema(args, tool.parameters);
+    if (coerced !== args) {
+      if (isRecord(args) && isRecord(coerced)) {
+        for (const key of Object.keys(args)) {
+          delete args[key];
+        }
+        Object.assign(args, coerced);
+      } else {
+        return validator.Check(coerced) ? coerced : args;
+      }
+    }
+  }
+  if (validator.Check(args)) {
+    return args;
+  }
+  const errors = validator.Errors(args).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join("\n") || "Unknown validation error";
+  const errorMessage = `Validation failed for tool "${toolCall.name}":
+${errors}
+
+Received arguments:
+${JSON.stringify(toolCall.arguments, null, 2)}`;
+  throw new Error(errorMessage);
+}
+
+export {
+  readAbsolutePathEnv,
+  assertProductStatePath,
+  resolveRuntimePaths,
+  shouldUseWindowsShell,
+  processIdExists,
+  isProcessAlive,
+  signalProcessGroupOrProcess,
+  waitForChildProcess,
+  normalizeSocketPath,
+  isBunBinary,
+  SELF_UPDATE_INTERACTIVE_CHILD_ENV,
+  SELF_UPDATE_NOT_ATTEMPTED_EXIT_CODE,
+  getSelfUpdateCommand,
+  getSelfUpdateUnavailableInstruction,
+  getPackageDir,
+  getPhysicalPackageDir,
+  getThemesDir,
+  getExportTemplateDir,
+  getPackageJsonPath,
+  getDocsPath,
+  getChangelogPath,
+  getBundledInteractiveAssetPath,
+  getBundledSkillsDir,
+  PACKAGE_NAME,
+  APP_NAME,
+  APP_TITLE,
+  CONFIG_DIR_NAME,
+  VERSION,
+  ENV_AGENT_DIR,
+  expandTildePath,
+  getAgentDir,
+  getCustomThemesDir,
+  getLogsDir,
+  getClientErrorLogPath,
+  getAgentLogPath,
+  getDaemonLogPath,
+  getDaemonUpdateRestartManifestPath,
+  getLegacyDaemonUpdateRestartManifestPath,
+  appendRotatingLog,
+  getAuthPath,
+  getCronJobsPath,
+  getBinDir,
+  getSessionsDir,
+  getSessionDirEnvOverride,
+  getDebugLogPath,
+  typebox_exports,
+  build_exports,
+  registerApiProvider,
+  isLocalFauxStream,
+  assertBuiltInAttemptSupport,
+  resetApiProviders,
+  streamSimple,
+  completeSimple,
+  isContextOverflow,
+  StringEnum,
+  validateToolArguments,
+  src_exports
+};