@spotpatch/shared 1.4.0 → 1.6.0

package/README.md

@@ -1,11 +1,23 @@
-# @spotpatch/shared
+<h1><a href="https://github.com/huanglvjing/spotpatch"><img src="https://raw.githubusercontent.com/huanglvjing/spotpatch/main/docs/assets/spotpatch-npm-icon.png" alt="SpotPatch" width="48" height="48" align="absmiddle" /></a> <code>@spotpatch/shared</code></h1>
 
-Immutable data models, bounded protocol schemas, constants, and error codes
-shared by the SpotPatch packages.
+## English
 
-Applications should install and configure
-[`@spotpatch/vite`](https://www.npmjs.com/package/@spotpatch/vite) instead of
-depending on this internal package directly.
+The shared contract package for SpotPatch. It provides immutable data models, bounded protocol schemas, endpoint constants, error codes, runtime bootstrap types, Agent events, and AI configuration types used across Node and browser packages.
 
-See the [SpotPatch repository](https://github.com/huanglvjing/spotpatch) for the
-public API and protocol documentation.
+Applications should install a framework adapter such as [`@spotpatch/vite`](https://www.npmjs.com/package/@spotpatch/vite) instead of depending on this package for UI integration. Changes to this package are versioned because they define compatibility between independently built SpotPatch packages.
+
+Requires Node.js `>=20.19.0` when used in Node environments.
+
+## 简体中文
+
+这是 SpotPatch 的共享契约包，提供不可变数据模型、有界协议 Schema、端点常量、错误码、Runtime bootstrap 类型、Agent 事件和 AI 配置类型，供 Node 与浏览器包共同使用。
+
+业务应用应安装 [`@spotpatch/vite`](https://www.npmjs.com/package/@spotpatch/vite) 等框架适配器，而不是把本包当作 UI 接入。该包独立版本化，是因为它定义了不同 SpotPatch 构建产物之间的兼容契约。
+
+在 Node 环境中使用时要求 Node.js `>=20.19.0`。
+
+## Links / 链接
+
+- [Repository / 仓库](https://github.com/huanglvjing/spotpatch)
+- [Public models / 公共模型](https://github.com/huanglvjing/spotpatch/blob/main/docs/%E6%8A%80%E6%9C%AF%E6%96%B9%E6%A1%88/03-%E5%85%AC%E5%85%B1API%E4%B8%8E%E6%95%B0%E6%8D%AE%E6%A8%A1%E5%9E%8B.md)
+- [MIT License / 许可证](https://github.com/huanglvjing/spotpatch/blob/main/LICENSE)

package/dist/index.cjs

@@ -37,6 +37,8 @@ __export(index_exports, {
   SPOTPATCH_ENDPOINTS: () => SPOTPATCH_ENDPOINTS,
   SPOTPATCH_LOCALES: () => SPOTPATCH_LOCALES,
   SPOTPATCH_LOCALE_PREFERENCES: () => SPOTPATCH_LOCALE_PREFERENCES,
+  SPOTPATCH_NEXT_BUNDLERS: () => SPOTPATCH_NEXT_BUNDLERS,
+  SPOTPATCH_NEXT_ROUTER_KINDS: () => SPOTPATCH_NEXT_ROUTER_KINDS,
   SPOTPATCH_REPOSITORY_URL: () => SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER: () => SPOTPATCH_TOKEN_HEADER,
   SpotPatchError: () => SpotPatchError,
@@ -58,6 +60,8 @@ __export(index_exports, {
   openEditorRequestSchema: () => openEditorRequestSchema,
   parseSourceMarker: () => parseSourceMarker,
   redactSensitiveText: () => redactSensitiveText,
+  runtimeBootstrapRequestSchema: () => runtimeBootstrapRequestSchema,
+  runtimeConfigSchema: () => runtimeConfigSchema,
   sanitizeUrl: () => sanitizeUrl,
   sourceContextRequestSchema: () => sourceContextRequestSchema,
   spotAnnotationRequestSchema: () => spotAnnotationRequestSchema,
@@ -191,9 +195,98 @@ var SPOTPATCH_LOCALE_PREFERENCES = Object.freeze([
   ...SPOTPATCH_LOCALES
 ]);
 
+// src/model/runtime-config.ts
+var import_zod = require("zod");
+
+// src/protocol/endpoints.ts
+var SPOTPATCH_API_BASE = "/__spotpatch/v1";
+var SPOTPATCH_TOKEN_HEADER = "X-SpotPatch-Token";
+var SPOTPATCH_ENDPOINTS = Object.freeze({
+  bootstrap: `${SPOTPATCH_API_BASE}/bootstrap`,
+  sourceContext: `${SPOTPATCH_API_BASE}/source-context`,
+  openEditor: `${SPOTPATCH_API_BASE}/open-editor`,
+  agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
+  agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
+  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
+});
+function getAgentJobEndpoint(jobId, action) {
+  return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
+}
+
 // src/model/editor.ts
 var SPOTPATCH_EDITOR_PREFERENCES = ["auto", "vscode", "cursor"];
 
+// src/model/runtime-config.ts
+var SPOTPATCH_NEXT_BUNDLERS = Object.freeze(["turbopack", "webpack"]);
+var SPOTPATCH_NEXT_ROUTER_KINDS = Object.freeze([
+  "app",
+  "pages",
+  "hybrid"
+]);
+var boundedText = (maximum) => import_zod.z.string().trim().min(1).max(maximum);
+var profileIdSchema = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var runtimeAiModelSchema = import_zod.z.strictObject({
+  id: profileIdSchema,
+  label: boundedText(100)
+});
+var runtimeAiProviderSchema = import_zod.z.strictObject({
+  id: profileIdSchema,
+  label: boundedText(100),
+  protocol: import_zod.z.enum(["responses", "chat-completions"]),
+  models: import_zod.z.array(runtimeAiModelSchema).min(1).max(64),
+  defaultModel: profileIdSchema
+}).refine(
+  ({ defaultModel, models }) => models.some(({ id }) => id === defaultModel) && new Set(models.map(({ id }) => id)).size === models.length,
+  { message: "Runtime AI model profiles are inconsistent." }
+);
+var runtimeAiConfigSchema = import_zod.z.discriminatedUnion("enabled", [
+  import_zod.z.strictObject({ enabled: import_zod.z.literal(false) }),
+  import_zod.z.strictObject({
+    enabled: import_zod.z.literal(true),
+    providers: import_zod.z.array(runtimeAiProviderSchema).min(1).max(32),
+    defaultProvider: profileIdSchema,
+    applyMode: import_zod.z.enum(["review", "auto"])
+  }).refine(
+    ({ defaultProvider, providers }) => providers.some(({ id }) => id === defaultProvider) && new Set(providers.map(({ id }) => id)).size === providers.length,
+    { message: "Runtime AI provider profiles are inconsistent." }
+  )
+]);
+var positiveInteger = import_zod.z.number().int().positive();
+var runtimeConfigBaseShape = {
+  apiBase: import_zod.z.literal(SPOTPATCH_API_BASE),
+  ai: runtimeAiConfigSchema,
+  budget: import_zod.z.strictObject({
+    totalCharacters: positiveInteger,
+    domCharacters: positiveInteger,
+    cssCharacters: positiveInteger,
+    codeCharacters: positiveInteger,
+    maxCodeLines: positiveInteger,
+    maxComponentDepth: positiveInteger
+  }),
+  debug: import_zod.z.boolean(),
+  editor: import_zod.z.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  frameworkVersion: boundedText(64),
+  locale: import_zod.z.enum(SPOTPATCH_LOCALE_PREFERENCES),
+  maxTargets: import_zod.z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
+  redact: import_zod.z.boolean(),
+  sessionId: import_zod.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  sessionToken: import_zod.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  shortcut: boundedText(128),
+  spotPatchVersion: boundedText(64)
+};
+var runtimeConfigSchema = import_zod.z.discriminatedUnion("framework", [
+  import_zod.z.strictObject({
+    ...runtimeConfigBaseShape,
+    framework: import_zod.z.literal("vite")
+  }),
+  import_zod.z.strictObject({
+    ...runtimeConfigBaseShape,
+    bundler: import_zod.z.enum(SPOTPATCH_NEXT_BUNDLERS),
+    framework: import_zod.z.literal("next"),
+    routerKind: import_zod.z.enum(SPOTPATCH_NEXT_ROUTER_KINDS)
+  })
+]);
+
 // src/model/agent.ts
 var DEFAULT_AGENT_LIMITS = Object.freeze({
   maxTurns: 20,
@@ -275,102 +368,91 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/endpoints.ts
-var SPOTPATCH_API_BASE = "/__spotpatch/v1";
-var SPOTPATCH_TOKEN_HEADER = "X-SpotPatch-Token";
-var SPOTPATCH_ENDPOINTS = Object.freeze({
-  sourceContext: `${SPOTPATCH_API_BASE}/source-context`,
-  openEditor: `${SPOTPATCH_API_BASE}/open-editor`,
-  agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
-  agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
-  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
-});
-function getAgentJobEndpoint(jobId, action) {
-  return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
-}
-
 // src/protocol/requests.ts
-var import_zod = require("zod");
-var sourceCoordinatesSchema = import_zod.z.strictObject({
-  fileId: import_zod.z.string().min(1).max(128),
-  line: import_zod.z.number().int().positive(),
-  column: import_zod.z.number().int().positive()
+var import_zod2 = require("zod");
+var runtimeBootstrapRequestSchema = import_zod2.z.strictObject({});
+var sourceCoordinatesSchema = import_zod2.z.strictObject({
+  fileId: import_zod2.z.string().min(1).max(128),
+  line: import_zod2.z.number().int().positive(),
+  column: import_zod2.z.number().int().positive()
 });
 var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod.z.number().int().positive()
+  maxLines: import_zod2.z.number().int().positive()
 }).strict();
 var openEditorRequestSchema = sourceCoordinatesSchema.strict();
-var profileIdSchema = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => import_zod.z.string().max(maximum);
-var sourceRefSchema = import_zod.z.strictObject({
+var profileIdSchema2 = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => import_zod2.z.string().max(maximum);
+var sourceRefSchema = import_zod2.z.strictObject({
   fileId: boundedString(128).optional(),
   relativePath: boundedString(1024).optional(),
-  line: import_zod.z.number().int().positive().optional(),
-  column: import_zod.z.number().int().positive().optional(),
-  origin: import_zod.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
+  line: import_zod2.z.number().int().positive().optional(),
+  column: import_zod2.z.number().int().positive().optional(),
+  origin: import_zod2.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod2.z.enum(["exact", "probable", "approximate", "unknown"])
 });
-var matchedStyleRuleSchema = import_zod.z.strictObject({
+var matchedStyleRuleSchema = import_zod2.z.strictObject({
   selector: boundedString(2048),
   declarations: boundedString(8192),
   source: boundedString(1024).optional(),
   media: boundedString(1024).optional()
 });
-var codeContextSchema = import_zod.z.strictObject({
+var codeContextSchema = import_zod2.z.strictObject({
   relativePath: boundedString(1024),
-  language: import_zod.z.enum(["tsx", "jsx"]),
-  startLine: import_zod.z.number().int().positive(),
-  endLine: import_zod.z.number().int().positive(),
+  language: import_zod2.z.enum(["tsx", "jsx"]),
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive(),
   excerpt: boundedString(16e3),
-  boundary: import_zod.z.enum(["component", "nearby-lines"])
+  boundary: import_zod2.z.enum(["component", "nearby-lines"])
 });
-var spotTargetContextRequestSchema = import_zod.z.strictObject({
-  instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+var pageContextSchema = import_zod2.z.strictObject({
+  url: boundedString(2048),
+  pathname: boundedString(2048),
+  title: boundedString(1024),
+  viewportWidth: import_zod2.z.number().nonnegative(),
+  viewportHeight: import_zod2.z.number().nonnegative(),
+  devicePixelRatio: import_zod2.z.number().positive()
+});
+var spotTargetContextRequestSchema = import_zod2.z.strictObject({
+  instruction: import_zod2.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+  page: pageContextSchema.optional(),
   source: sourceRefSchema,
-  react: import_zod.z.strictObject({
-    supported: import_zod.z.boolean(),
+  react: import_zod2.z.strictObject({
+    supported: import_zod2.z.boolean(),
     version: boundedString(64).optional(),
     componentName: boundedString(256).optional(),
-    componentStack: import_zod.z.array(boundedString(256)).max(64),
+    componentStack: import_zod2.z.array(boundedString(256)).max(64),
     source: sourceRefSchema.optional()
   }),
-  element: import_zod.z.strictObject({
+  element: import_zod2.z.strictObject({
     tagName: boundedString(128),
     selector: boundedString(2048),
     sanitizedHtml: boundedString(8192),
     textPreview: boundedString(2048).optional(),
     role: boundedString(256).optional(),
-    rect: import_zod.z.strictObject({
-      x: import_zod.z.number(),
-      y: import_zod.z.number(),
-      width: import_zod.z.number().nonnegative(),
-      height: import_zod.z.number().nonnegative()
+    rect: import_zod2.z.strictObject({
+      x: import_zod2.z.number(),
+      y: import_zod2.z.number(),
+      width: import_zod2.z.number().nonnegative(),
+      height: import_zod2.z.number().nonnegative()
     })
   }),
-  styles: import_zod.z.strictObject({
-    classNames: import_zod.z.array(boundedString(512)).max(256),
+  styles: import_zod2.z.strictObject({
+    classNames: import_zod2.z.array(boundedString(512)).max(256),
     inlineStyle: boundedString(8192).optional(),
-    matchedRules: import_zod.z.array(matchedStyleRuleSchema).max(256),
-    computed: import_zod.z.record(boundedString(256), boundedString(2048)),
-    warnings: import_zod.z.array(boundedString(1024)).max(64)
+    matchedRules: import_zod2.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod2.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod2.z.array(boundedString(1024)).max(64)
   }),
   code: codeContextSchema.optional(),
-  warnings: import_zod.z.array(boundedString(1024)).max(64)
+  warnings: import_zod2.z.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(3),
+var spotAnnotationRequestSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(3),
   id: boundedString(128),
-  locale: import_zod.z.enum(SPOTPATCH_LOCALES),
-  page: import_zod.z.strictObject({
-    url: boundedString(2048),
-    pathname: boundedString(2048),
-    title: boundedString(1024),
-    viewportWidth: import_zod.z.number().nonnegative(),
-    viewportHeight: import_zod.z.number().nonnegative(),
-    devicePixelRatio: import_zod.z.number().positive()
-  }),
-  targets: import_zod.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: import_zod.z.iso.datetime()
+  locale: import_zod2.z.enum(SPOTPATCH_LOCALES),
+  page: pageContextSchema,
+  targets: import_zod2.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod2.z.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
     (characters, target) => characters + target.instruction.length,
@@ -384,51 +466,51 @@ var spotAnnotationRequestSchema = import_zod.z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = import_zod.z.strictObject({
-  providerProfileId: profileIdSchema,
-  modelProfileId: profileIdSchema
+var agentCapabilityRequestSchema = import_zod2.z.strictObject({
+  providerProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema2
 });
-var agentWorkspaceHealthRequestSchema = import_zod.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod.z.strictObject({
+var agentWorkspaceHealthRequestSchema = import_zod2.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod2.z.strictObject({
   annotation: spotAnnotationRequestSchema,
-  providerProfileId: profileIdSchema,
-  modelProfileId: profileIdSchema,
-  providerDataConsent: import_zod.z.literal(true),
-  workingTreeMode: import_zod.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema2,
+  providerDataConsent: import_zod2.z.literal(true),
+  workingTreeMode: import_zod2.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
 });
-var agentJobActionRequestSchema = import_zod.z.strictObject({});
+var agentJobActionRequestSchema = import_zod2.z.strictObject({});
 
 // src/protocol/agent-schemas.ts
-var import_zod2 = require("zod");
-var profileIdSchema2 = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => import_zod2.z.string().max(maximum);
-var errorCodeSchema = import_zod2.z.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = import_zod2.z.strictObject({
-  providerProfileId: profileIdSchema2,
+var import_zod3 = require("zod");
+var profileIdSchema3 = import_zod3.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => import_zod3.z.string().max(maximum);
+var errorCodeSchema = import_zod3.z.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = import_zod3.z.strictObject({
+  providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
-  protocol: import_zod2.z.enum(["responses", "chat-completions"]),
-  state: import_zod2.z.enum(AGENT_CAPABILITY_STATES),
-  authenticated: import_zod2.z.boolean(),
-  modelAvailable: import_zod2.z.boolean(),
-  toolCalling: import_zod2.z.boolean(),
-  toolResultContinuation: import_zod2.z.boolean(),
-  streaming: import_zod2.z.boolean(),
-  checkedAt: import_zod2.z.iso.datetime().optional(),
+  protocol: import_zod3.z.enum(["responses", "chat-completions"]),
+  state: import_zod3.z.enum(AGENT_CAPABILITY_STATES),
+  authenticated: import_zod3.z.boolean(),
+  modelAvailable: import_zod3.z.boolean(),
+  toolCalling: import_zod3.z.boolean(),
+  toolResultContinuation: import_zod3.z.boolean(),
+  streaming: import_zod3.z.boolean(),
+  checkedAt: import_zod3.z.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = import_zod2.z.strictObject({
-  state: import_zod2.z.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: import_zod2.z.iso.datetime(),
-  changes: import_zod2.z.strictObject({
-    staged: import_zod2.z.number().int().nonnegative(),
-    unstaged: import_zod2.z.number().int().nonnegative(),
-    untracked: import_zod2.z.number().int().nonnegative(),
-    conflicted: import_zod2.z.number().int().nonnegative(),
-    total: import_zod2.z.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = import_zod3.z.strictObject({
+  state: import_zod3.z.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: import_zod3.z.iso.datetime(),
+  changes: import_zod3.z.strictObject({
+    staged: import_zod3.z.number().int().nonnegative(),
+    unstaged: import_zod3.z.number().int().nonnegative(),
+    untracked: import_zod3.z.number().int().nonnegative(),
+    conflicted: import_zod3.z.number().int().nonnegative(),
+    total: import_zod3.z.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: import_zod2.z.boolean(),
+  canIncludeLocalChanges: import_zod3.z.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -446,42 +528,42 @@ var agentWorkspaceHealthSnapshotSchema = import_zod2.z.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = import_zod2.z.strictObject({
+var agentChangedFileSchema = import_zod3.z.strictObject({
   relativePath: boundedString2(1024),
-  kind: import_zod2.z.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: import_zod2.z.number().int().nonnegative(),
-  deletions: import_zod2.z.number().int().nonnegative()
+  kind: import_zod3.z.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: import_zod3.z.number().int().nonnegative(),
+  deletions: import_zod3.z.number().int().nonnegative()
 });
-var agentCheckResultSchema = import_zod2.z.strictObject({
-  checkId: profileIdSchema2,
+var agentCheckResultSchema = import_zod3.z.strictObject({
+  checkId: profileIdSchema3,
   label: boundedString2(100),
-  status: import_zod2.z.enum(AGENT_CHECK_STATUSES),
-  durationMs: import_zod2.z.number().int().nonnegative(),
+  status: import_zod3.z.enum(AGENT_CHECK_STATUSES),
+  durationMs: import_zod3.z.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-var agentJobSnapshotSchema = import_zod2.z.strictObject({
-  jobId: import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod2.z.enum(AGENT_JOB_STATUSES),
-  providerProfileId: profileIdSchema2,
+var agentJobSnapshotSchema = import_zod3.z.strictObject({
+  jobId: import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod3.z.enum(AGENT_JOB_STATUSES),
+  providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  createdAt: import_zod2.z.iso.datetime(),
-  updatedAt: import_zod2.z.iso.datetime(),
-  canCancel: import_zod2.z.boolean(),
-  canApply: import_zod2.z.boolean(),
-  canRevert: import_zod2.z.boolean(),
+  createdAt: import_zod3.z.iso.datetime(),
+  updatedAt: import_zod3.z.iso.datetime(),
+  canCancel: import_zod3.z.boolean(),
+  canApply: import_zod3.z.boolean(),
+  canRevert: import_zod3.z.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = import_zod2.z.strictObject({
-  jobId: import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = import_zod3.z.strictObject({
+  jobId: import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: import_zod2.z.array(agentChangedFileSchema).max(100),
-  checks: import_zod2.z.array(agentCheckResultSchema).max(100)
+  files: import_zod3.z.array(agentChangedFileSchema).max(100),
+  checks: import_zod3.z.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = import_zod2.z.strictObject({
+var agentJobResultResponseSchema = import_zod3.z.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -493,44 +575,44 @@ var agentJobResultResponseSchema = import_zod2.z.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = import_zod2.z.strictObject({
-  schemaVersion: import_zod2.z.literal(2),
-  sequence: import_zod2.z.number().int().positive(),
-  jobId: import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod2.z.enum(AGENT_JOB_STATUSES),
-  timestamp: import_zod2.z.iso.datetime()
+var agentJobEventBaseSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(2),
+  sequence: import_zod3.z.number().int().positive(),
+  jobId: import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod3.z.enum(AGENT_JOB_STATUSES),
+  timestamp: import_zod3.z.iso.datetime()
 });
-var agentJobEventSchema = import_zod2.z.discriminatedUnion("type", [
+var agentJobEventSchema = import_zod3.z.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("snapshot"),
-    data: import_zod2.z.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: import_zod3.z.literal("snapshot"),
+    data: import_zod3.z.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("phase"),
-    data: import_zod2.z.strictObject({ message: boundedString2(1024) })
+    type: import_zod3.z.literal("phase"),
+    data: import_zod3.z.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("tool"),
-    data: import_zod2.z.strictObject({
-      turn: import_zod2.z.number().int().positive(),
+    type: import_zod3.z.literal("tool"),
+    data: import_zod3.z.strictObject({
+      turn: import_zod3.z.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: import_zod2.z.enum(["started", "succeeded", "failed"]),
+      state: import_zod3.z.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("check"),
-    data: import_zod2.z.strictObject({ result: agentCheckResultSchema })
+    type: import_zod3.z.literal("check"),
+    data: import_zod3.z.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("result-ready"),
-    data: import_zod2.z.strictObject({ hasResult: import_zod2.z.literal(true) })
+    type: import_zod3.z.literal("result-ready"),
+    data: import_zod3.z.strictObject({ hasResult: import_zod3.z.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod2.z.literal("error"),
-    data: import_zod2.z.strictObject({
+    type: import_zod3.z.literal("error"),
+    data: import_zod3.z.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -576,6 +658,8 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   SPOTPATCH_ENDPOINTS,
   SPOTPATCH_LOCALES,
   SPOTPATCH_LOCALE_PREFERENCES,
+  SPOTPATCH_NEXT_BUNDLERS,
+  SPOTPATCH_NEXT_ROUTER_KINDS,
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
@@ -597,6 +681,8 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   openEditorRequestSchema,
   parseSourceMarker,
   redactSensitiveText,
+  runtimeBootstrapRequestSchema,
+  runtimeConfigSchema,
   sanitizeUrl,
   sourceContextRequestSchema,
   spotAnnotationRequestSchema,