@spotpatch/shared 1.11.0 → 1.13.0

package/dist/external-agent-node.cjs

@@ -59,13 +59,13 @@ var import_node_crypto = require("crypto");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/protocol/external-handoff.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/protocol/requests.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
 // src/model/annotation.ts
 var MAX_ANNOTATION_TARGETS = 20;
@@ -140,35 +140,8 @@ var AGENT_CHECK_STATUSES = Object.freeze([
   "timed-out"
 ]);
 
-// src/protocol/requests.ts
-var runtimeBootstrapRequestSchema = import_zod.z.strictObject({});
-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 sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod.z.number().int().positive()
-}).strict();
-var openEditorRequestSchema = sourceCoordinatesSchema.strict();
-var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: import_zod.z.literal(1),
-  sourceVersion: import_zod.z.string().min(1).max(128).optional()
-}).strict();
-var dataFlowComponentIdentityRequestSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(1),
-  componentSourceId: import_zod.z.string().min(1).max(128),
-  sourceVersion: import_zod.z.string().min(1).max(128)
-});
-var dataFlowComponentReportRequestSchema = import_zod.z.union([
-  dataFlowSourceCoordinatesRequestSchema,
-  dataFlowComponentIdentityRequestSchema
-]);
-var dataFlowPageReportRequestSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(1),
-  targets: import_zod.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
-});
-var profileIdSchema = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+// src/model/context-schema.ts
+var import_zod = require("zod");
 var boundedString = (maximum) => import_zod.z.string().max(maximum);
 var sourceRefSchema = import_zod.z.strictObject({
   fileId: boundedString(128).optional(),
@@ -200,7 +173,7 @@ var pageContextSchema = import_zod.z.strictObject({
   viewportHeight: import_zod.z.number().nonnegative(),
   devicePixelRatio: import_zod.z.number().positive()
 });
-var spotTargetContextRequestSchema = import_zod.z.strictObject({
+var spotTargetContextSchema = import_zod.z.strictObject({
   instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
   page: pageContextSchema.optional(),
   source: sourceRefSchema,
@@ -236,12 +209,12 @@ var spotTargetContextRequestSchema = import_zod.z.strictObject({
   code: codeContextSchema.optional(),
   warnings: import_zod.z.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = import_zod.z.strictObject({
+var spotAnnotationSchema = import_zod.z.strictObject({
   schemaVersion: import_zod.z.literal(3),
   id: boundedString(128),
   locale: import_zod.z.enum(SPOTPATCH_LOCALES),
   page: pageContextSchema,
-  targets: import_zod.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  targets: import_zod.z.array(spotTargetContextSchema).min(1).max(MAX_ANNOTATION_TARGETS),
   createdAt: import_zod.z.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
@@ -256,21 +229,51 @@ var spotAnnotationRequestSchema = import_zod.z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = import_zod.z.strictObject({
+
+// src/protocol/requests.ts
+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_zod2.z.number().int().positive()
+}).strict();
+var openEditorRequestSchema = sourceCoordinatesSchema.strict();
+var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
+  schemaVersion: import_zod2.z.literal(1),
+  sourceVersion: import_zod2.z.string().min(1).max(128).optional()
+}).strict();
+var dataFlowComponentIdentityRequestSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(1),
+  componentSourceId: import_zod2.z.string().min(1).max(128),
+  sourceVersion: import_zod2.z.string().min(1).max(128)
+});
+var dataFlowComponentReportRequestSchema = import_zod2.z.union([
+  dataFlowSourceCoordinatesRequestSchema,
+  dataFlowComponentIdentityRequestSchema
+]);
+var dataFlowPageReportRequestSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(1),
+  targets: import_zod2.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+});
+var profileIdSchema = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var agentCapabilityRequestSchema = import_zod2.z.strictObject({
   providerProfileId: profileIdSchema,
   modelProfileId: profileIdSchema
 });
-var agentWorkspaceHealthRequestSchema = import_zod.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod.z.strictObject({
-  annotation: spotAnnotationRequestSchema,
-  applyMode: import_zod.z.enum(AGENT_APPLY_MODES).optional(),
+var agentWorkspaceHealthRequestSchema = import_zod2.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod2.z.strictObject({
+  annotation: spotAnnotationSchema,
+  applyMode: import_zod2.z.enum(AGENT_APPLY_MODES).optional(),
   providerProfileId: profileIdSchema,
   modelProfileId: profileIdSchema,
-  providerDataConsent: import_zod.z.literal(true),
-  trustedFastModeConsent: import_zod.z.literal(true).optional(),
-  workingTreeMode: import_zod.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerDataConsent: import_zod2.z.literal(true),
+  trustedFastModeConsent: import_zod2.z.literal(true).optional(),
+  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/external-handoff-constants.ts
 var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -336,44 +339,44 @@ var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
 });
 
 // src/protocol/external-handoff.ts
-var opaqueIdSchema = import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var isoTimestampSchema = import_zod2.z.iso.datetime();
-var externalHandoffReportableDispatchPhaseSchema = import_zod2.z.enum(
+var opaqueIdSchema = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema = import_zod3.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod3.z.enum(
   EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
 );
-var externalHandoffPageSummarySchema = import_zod2.z.strictObject({
-  origin: import_zod2.z.string().min(1).max(2048),
-  pathname: import_zod2.z.string().min(1).max(2048)
+var externalHandoffPageSummarySchema = import_zod3.z.strictObject({
+  origin: import_zod3.z.string().min(1).max(2048),
+  pathname: import_zod3.z.string().min(1).max(2048)
 });
-var externalHandoffSummarySchema = import_zod2.z.strictObject({
+var externalHandoffSummarySchema = import_zod3.z.strictObject({
   sessionId: opaqueIdSchema,
-  framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
-  revision: import_zod2.z.number().int().positive(),
+  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod3.z.number().int().positive(),
   cursor: opaqueIdSchema,
-  targetCount: import_zod2.z.number().int().positive(),
+  targetCount: import_zod3.z.number().int().positive(),
   page: externalHandoffPageSummarySchema,
   publishedAt: isoTimestampSchema,
   expiresAt: isoTimestampSchema,
-  state: import_zod2.z.enum(EXTERNAL_HANDOFF_STATES),
-  pickupCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  state: import_zod3.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod3.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
   pickedUpAt: isoTimestampSchema.optional()
 });
-var externalHandoffSnapshotSchema = import_zod2.z.strictObject({
-  schemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+var externalHandoffSnapshotSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
   cursor: opaqueIdSchema,
-  session: import_zod2.z.strictObject({
+  session: import_zod3.z.strictObject({
     id: opaqueIdSchema,
-    framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+    framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
   }),
-  revision: import_zod2.z.number().int().positive(),
+  revision: import_zod3.z.number().int().positive(),
   publishedAt: isoTimestampSchema,
   expiresAt: isoTimestampSchema,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var activeAdapterSummarySchema = import_zod2.z.strictObject({
-  kind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  state: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
-  canDispatch: import_zod2.z.boolean(),
+var activeAdapterSummarySchema = import_zod3.z.strictObject({
+  kind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod3.z.boolean(),
   connectedAt: isoTimestampSchema,
   updatedAt: isoTimestampSchema
 }).superRefine((value, context) => {
@@ -385,47 +388,47 @@ var activeAdapterSummarySchema = import_zod2.z.strictObject({
     });
   }
 });
-var dispatchSummarySchema = import_zod2.z.strictObject({
-  adapterKind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  revision: import_zod2.z.number().int().positive(),
-  phase: import_zod2.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+var dispatchSummarySchema = import_zod3.z.strictObject({
+  adapterKind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod3.z.number().int().positive(),
+  phase: import_zod3.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
   updatedAt: isoTimestampSchema
 });
-var externalHandoffCapabilityRequestSchema = import_zod2.z.strictObject({});
-var externalHandoffPublishRequestSchema = import_zod2.z.strictObject({
+var externalHandoffCapabilityRequestSchema = import_zod3.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod3.z.strictObject({
   requestId: opaqueIdSchema,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var externalHandoffStatusRequestSchema = import_zod2.z.strictObject({
+var externalHandoffStatusRequestSchema = import_zod3.z.strictObject({
   cursor: opaqueIdSchema.optional()
 });
-var externalHandoffResolveDeliveryRequestSchema = import_zod2.z.strictObject({
+var externalHandoffResolveDeliveryRequestSchema = import_zod3.z.strictObject({
   cursor: opaqueIdSchema,
-  confirmation: import_zod2.z.literal("workspace-reviewed")
-});
-var externalHandoffCapabilitySchema = import_zod2.z.strictObject({
-  enabled: import_zod2.z.literal(true),
-  brokerReady: import_zod2.z.boolean(),
-  activeWaitCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
-  snapshotSchemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
-  brokerProtocolVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  confirmation: import_zod3.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod3.z.strictObject({
+  enabled: import_zod3.z.literal(true),
+  brokerReady: import_zod3.z.boolean(),
+  activeWaitCount: import_zod3.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
-var externalHandoffPublishDeliverySchema = import_zod2.z.discriminatedUnion("mode", [
-  import_zod2.z.strictObject({ mode: import_zod2.z.literal("inbox") }),
-  import_zod2.z.strictObject({
-    mode: import_zod2.z.literal("active"),
+var externalHandoffPublishDeliverySchema = import_zod3.z.discriminatedUnion("mode", [
+  import_zod3.z.strictObject({ mode: import_zod3.z.literal("inbox") }),
+  import_zod3.z.strictObject({
+    mode: import_zod3.z.literal("active"),
     adapter: activeAdapterSummarySchema,
     dispatch: dispatchSummarySchema
   })
 ]);
-var externalHandoffPublishResultSchema = import_zod2.z.strictObject({
+var externalHandoffPublishResultSchema = import_zod3.z.strictObject({
   handoff: externalHandoffSummarySchema,
   delivery: externalHandoffPublishDeliverySchema,
-  replayed: import_zod2.z.boolean()
+  replayed: import_zod3.z.boolean()
 });
-var externalHandoffStatusResultSchema = import_zod2.z.strictObject({
+var externalHandoffStatusResultSchema = import_zod3.z.strictObject({
   handoff: externalHandoffSummarySchema,
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
@@ -488,6 +491,24 @@ var ERROR_CODES = {
   APPLY_CONFLICT: "APPLY_CONFLICT",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
+var CONTEXTUAL_ASK_ERROR_CODES = Object.freeze([
+  "ASK_DISABLED",
+  "ASK_SELECTION_REQUIRED",
+  "ASK_SELECTION_STALE",
+  "ASK_QUESTION_INVALID",
+  "ASK_EXECUTOR_UNAVAILABLE",
+  "ASK_TIMEOUT",
+  "ASK_CONSENT_REQUIRED",
+  "ASK_BUSY",
+  "ASK_IDEMPOTENCY_CONFLICT",
+  "ASK_SOURCE_SCOPE_DENIED",
+  "ASK_LIMIT_EXCEEDED",
+  "ASK_ANSWER_INVALID",
+  "ASK_WRITE_ATTEMPTED",
+  "ASK_CANCELLED",
+  "ASK_RESULT_EXPIRED",
+  "ASK_PROTOCOL_INCOMPATIBLE"
+]);
 var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
 
 // src/errors/spotpatch-error.ts
@@ -513,9 +534,9 @@ var SPOTPATCH_BRIDGE_PATHS = Object.freeze({
   activeRelease: "/bridge/v1/active/release"
 });
 var EXTERNAL_HANDOFF_PROJECT_KEY_SALT = "spotpatch-external-agent-project-v1";
-var opaqueIdSchema2 = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var projectKeySchema = import_zod3.z.string().length(64).regex(/^[a-f0-9]+$/u);
-var loopbackEndpointSchema = import_zod3.z.url().refine((value) => {
+var opaqueIdSchema2 = import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var projectKeySchema = import_zod4.z.string().length(64).regex(/^[a-f0-9]+$/u);
+var loopbackEndpointSchema = import_zod4.z.url().refine((value) => {
   const match = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/u.exec(value);
   if (match?.[1] === void 0) {
     return false;
@@ -523,69 +544,69 @@ var loopbackEndpointSchema = import_zod3.z.url().refine((value) => {
   const port = Number(match[1]);
   return Number.isSafeInteger(port) && port <= 65535;
 });
-var externalHandoffDescriptorSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+var externalHandoffDescriptorSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  brokerProtocolVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   projectKey: projectKeySchema,
   sessionId: opaqueIdSchema2,
-  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
   endpoint: loopbackEndpointSchema,
-  bridgeToken: import_zod3.z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-  pid: import_zod3.z.number().int().positive(),
-  createdAt: import_zod3.z.iso.datetime()
+  bridgeToken: import_zod4.z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  pid: import_zod4.z.number().int().positive(),
+  createdAt: import_zod4.z.iso.datetime()
 });
-var bridgeStatusRequestSchema = import_zod3.z.strictObject({});
-var bridgeCurrentRequestSchema = import_zod3.z.strictObject({
+var bridgeStatusRequestSchema = import_zod4.z.strictObject({});
+var bridgeCurrentRequestSchema = import_zod4.z.strictObject({
   cursor: opaqueIdSchema2.optional()
 });
-var bridgeWaitRequestSchema = import_zod3.z.strictObject({
+var bridgeWaitRequestSchema = import_zod4.z.strictObject({
   afterCursor: opaqueIdSchema2.optional(),
-  timeoutMs: import_zod3.z.number().int().positive().max(EXTERNAL_HANDOFF_LIMITS.maximumWaitMs).default(EXTERNAL_HANDOFF_LIMITS.defaultWaitMs)
+  timeoutMs: import_zod4.z.number().int().positive().max(EXTERNAL_HANDOFF_LIMITS.maximumWaitMs).default(EXTERNAL_HANDOFF_LIMITS.defaultWaitMs)
 });
-var bridgeAckRequestSchema = import_zod3.z.strictObject({
+var bridgeAckRequestSchema = import_zod4.z.strictObject({
   cursor: opaqueIdSchema2,
   connectorInstanceId: opaqueIdSchema2
 });
-var bridgeActiveClaimRequestSchema = import_zod3.z.strictObject({
-  adapterKind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+var bridgeActiveClaimRequestSchema = import_zod4.z.strictObject({
+  adapterKind: import_zod4.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
   connectorInstanceId: opaqueIdSchema2
 });
-var bridgeActiveHeartbeatRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveHeartbeatRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2
 });
-var bridgeActiveReportRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveReportRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2,
   cursor: opaqueIdSchema2,
   phase: externalHandoffReportableDispatchPhaseSchema
 });
-var bridgeActiveReleaseRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveReleaseRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2
 });
-var bridgeStatusSchema = import_zod3.z.strictObject({
-  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+var bridgeStatusSchema = import_zod4.z.strictObject({
+  brokerProtocolVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   projectKey: projectKeySchema,
   sessionId: opaqueIdSchema2,
-  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
   current: externalHandoffSummarySchema.nullable()
 });
-var bridgeCurrentResultSchema = import_zod3.z.strictObject({
-  outcome: import_zod3.z.literal("handoff"),
+var bridgeCurrentResultSchema = import_zod4.z.strictObject({
+  outcome: import_zod4.z.literal("handoff"),
   snapshot: externalHandoffSnapshotSchema
 });
-var bridgeWaitResultSchema = import_zod3.z.discriminatedUnion("outcome", [
+var bridgeWaitResultSchema = import_zod4.z.discriminatedUnion("outcome", [
   bridgeCurrentResultSchema,
-  import_zod3.z.strictObject({ outcome: import_zod3.z.literal("timeout") })
+  import_zod4.z.strictObject({ outcome: import_zod4.z.literal("timeout") })
 ]);
-var bridgeAckResultSchema = import_zod3.z.strictObject({
+var bridgeAckResultSchema = import_zod4.z.strictObject({
   summary: externalHandoffSummarySchema
 });
-var bridgeActiveClaimResultSchema = import_zod3.z.strictObject({
+var bridgeActiveClaimResultSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2,
-  heartbeatIntervalMs: import_zod3.z.literal(EXTERNAL_HANDOFF_LIMITS.activeHeartbeatIntervalMs),
+  heartbeatIntervalMs: import_zod4.z.literal(EXTERNAL_HANDOFF_LIMITS.activeHeartbeatIntervalMs),
   baselineCursor: opaqueIdSchema2.nullable(),
   activeAdapter: activeAdapterSummarySchema
 });
-var bridgeActiveStateResultSchema = import_zod3.z.strictObject({
+var bridgeActiveStateResultSchema = import_zod4.z.strictObject({
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });