@cleocode/adapters 2026.9.25 → 2026.10.1

package/dist/index.js

@@ -2339,7 +2339,7 @@ var init_output_contracts_data = __esm({
               // T12503: the optimistic-concurrency version agents pass to --if-match.
               updatedAt: {
                 type: ["string", "null"],
-                description: "Task version for optimistic concurrency: pass it to `cleo update|complete --if-match`."
+                description: "Task version for optimistic concurrency: pass it to `cleo update|complete --if-match`. A stale version fails with E_CONFLICT (23); E_TASK_RENAMED (26) when sync re-numbered the task you read (details.expected is its new id)."
               },
               // T12502: the human assignee and the agent claim lease are separate.
               assignee: {
@@ -17669,6 +17669,210 @@ var init_nexus_account = __esm({
   }
 });
 
+// packages/contracts/src/nexus-cloud.ts
+import { z as z26 } from "zod";
+var NEXUS_DEVICE_STATES, NEXUS_CLOUD_PROFILES, NEXUS_DEVICE_STATE_UNKNOWN, isoTime, profile, deviceState, nexusCloudCredentialSchema, nexusCloudDeviceSchema, nexusCloudOrganizationSchema, nexusCloudUserSchema, nexusCloudWhoamiSchema, nexusCloudDevicePageSchema, nexusCloudPresenceSchema, nexusCloudReplicaSchema, nexusCloudDeviceCountsSchema, projectFields, nexusCloudProjectListItemSchema, nexusCloudProjectPageSchema, nexusCloudProjectDetailSchema, nexusCloudReplicaPageSchema, NEXUS_STATUS_CHECK_IDS, NEXUS_STATUS_VERDICTS, CLOUD_STATUS_VERDICTS, knownCheckId, nexusCloudStatusCheckSchema, nexusCloudStatusSchema;
+var init_nexus_cloud = __esm({
+  "packages/contracts/src/nexus-cloud.ts"() {
+    "use strict";
+    NEXUS_DEVICE_STATES = ["active", "signed-out", "revoked"];
+    NEXUS_CLOUD_PROFILES = ["device", "read-only"];
+    NEXUS_DEVICE_STATE_UNKNOWN = "unknown";
+    isoTime = z26.iso.datetime({ offset: true });
+    profile = z26.enum(NEXUS_CLOUD_PROFILES).nullable().catch(null);
+    deviceState = z26.enum([...NEXUS_DEVICE_STATES, NEXUS_DEVICE_STATE_UNKNOWN]).catch(NEXUS_DEVICE_STATE_UNKNOWN);
+    nexusCloudCredentialSchema = z26.object({
+      kind: z26.enum(["device", "session"]),
+      credentialId: z26.string().nullable().optional(),
+      profile: profile.optional(),
+      scopes: z26.array(z26.string()).default([]),
+      createdAt: isoTime.nullable().optional(),
+      lastUsedAt: isoTime.nullable().optional(),
+      /** When the credential expires if it is not used again; null for sessions. */
+      idleExpiresAt: isoTime.nullable().optional()
+    });
+    nexusCloudDeviceSchema = z26.object({
+      deviceId: z26.string(),
+      name: z26.string(),
+      platform: z26.string().optional(),
+      arch: z26.string().nullable().optional(),
+      cliVersion: z26.string().nullable().optional(),
+      createdAt: isoTime.optional(),
+      lastSeenAt: isoTime.nullable().optional(),
+      state: deviceState,
+      signedOutAt: isoTime.nullable().optional(),
+      /** Base64 device certificate; null until the device holds a key grant. */
+      certificate: z26.string().nullable().optional(),
+      /** The current credential's profile, or null with none (signed out or revoked). */
+      profile: profile.optional(),
+      /** True for the device whose credential made this request. */
+      current: z26.boolean().default(false),
+      projects: z26.number().int().nonnegative().optional(),
+      replicas: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional()
+    });
+    nexusCloudOrganizationSchema = z26.object({
+      id: z26.string(),
+      name: z26.string(),
+      slug: z26.string().nullable().optional(),
+      role: z26.string().optional(),
+      personal: z26.boolean().optional()
+    });
+    nexusCloudUserSchema = z26.object({
+      id: z26.string(),
+      email: z26.string(),
+      name: z26.string().nullable().optional()
+    });
+    nexusCloudWhoamiSchema = z26.object({
+      serverTime: isoTime.optional(),
+      user: nexusCloudUserSchema,
+      organizations: z26.array(nexusCloudOrganizationSchema).default([]),
+      credential: nexusCloudCredentialSchema,
+      /** The calling device; null for a session caller. */
+      device: nexusCloudDeviceSchema.nullable()
+    });
+    nexusCloudDevicePageSchema = z26.object({
+      devices: z26.array(nexusCloudDeviceSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    nexusCloudPresenceSchema = z26.looseObject({
+      observedAt: isoTime.optional(),
+      sync: z26.object({ enabled: z26.boolean() }).optional()
+    });
+    nexusCloudReplicaSchema = z26.object({
+      projectId: z26.string(),
+      replicaId: z26.string(),
+      deviceId: z26.string(),
+      deviceName: z26.string(),
+      deviceState: deviceState.optional(),
+      attachedAt: isoTime.optional(),
+      lastSyncAt: isoTime.nullable(),
+      presence: nexusCloudPresenceSchema.nullable(),
+      presenceAt: isoTime.nullable()
+    });
+    nexusCloudDeviceCountsSchema = z26.object({
+      active: z26.number().int().nonnegative(),
+      total: z26.number().int().nonnegative()
+    });
+    projectFields = {
+      projectId: z26.string(),
+      label: z26.string().nullable(),
+      organizationId: z26.string(),
+      organizationName: z26.string().optional(),
+      remoteUrl: z26.string().nullable().optional(),
+      createdAt: isoTime.optional()
+    };
+    nexusCloudProjectListItemSchema = z26.object({
+      ...projectFields,
+      role: z26.string(),
+      streamId: z26.string().optional(),
+      headSeq: z26.number().int().nonnegative().nullable().optional(),
+      openConflicts: z26.number().int().nonnegative().optional(),
+      replicas: z26.array(nexusCloudReplicaSchema).default([]),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional(),
+      /** This project's replica list was cut at 50 (T12858). */
+      replicasTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectPageSchema = z26.object({
+      projects: z26.array(nexusCloudProjectListItemSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      /** Anything in the page was cut (the project list or a replica list). */
+      truncated: z26.boolean().default(false),
+      /** The project list itself was cut at 1000 (T12858). */
+      projectsTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectDetailSchema = z26.object({
+      project: z26.object({ ...projectFields, deletedAt: isoTime.nullable().optional() }),
+      role: z26.string(),
+      canTrash: z26.boolean().optional(),
+      openConflicts: z26.number().int().nonnegative(),
+      /** At most 50, oldest attachment first. */
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema,
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      /** `replicas` was cut at 50. */
+      truncated: z26.boolean().default(false),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable()
+      }).nullable()
+    });
+    nexusCloudReplicaPageSchema = z26.object({
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    NEXUS_STATUS_CHECK_IDS = [
+      "credential.valid",
+      "device.registered",
+      "device.active",
+      "device.certified",
+      "project.registered",
+      "project.writable",
+      "replica.attached",
+      "presence.fresh",
+      "replica.synced",
+      "conflicts.none"
+    ];
+    NEXUS_STATUS_VERDICTS = ["ok", "attention", "not-linked", "not-registered"];
+    CLOUD_STATUS_VERDICTS = [...NEXUS_STATUS_VERDICTS, "not-signed-in"];
+    knownCheckId = z26.enum(NEXUS_STATUS_CHECK_IDS);
+    nexusCloudStatusCheckSchema = z26.object({
+      id: z26.enum(NEXUS_STATUS_CHECK_IDS),
+      ok: z26.boolean(),
+      required: z26.boolean(),
+      detail: z26.string()
+    });
+    nexusCloudStatusSchema = z26.object({
+      serverTime: isoTime.optional(),
+      apiVersion: z26.string().optional(),
+      user: nexusCloudUserSchema,
+      credential: nexusCloudCredentialSchema,
+      device: nexusCloudDeviceSchema.nullable(),
+      project: z26.object({
+        projectId: z26.string(),
+        registered: z26.boolean(),
+        organizationId: z26.string().nullable(),
+        organizationName: z26.string().nullable(),
+        role: z26.string().nullable()
+      }).nullable(),
+      replica: z26.object({
+        replicaId: z26.string(),
+        attached: z26.boolean(),
+        attachedElsewhere: z26.boolean(),
+        attachedAt: isoTime.nullable(),
+        lastSyncAt: isoTime.nullable(),
+        presenceAt: isoTime.nullable(),
+        lastReplicaSeq: z26.number().int().nonnegative().nullable().optional()
+      }).nullable(),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable(),
+        openConflicts: z26.number().int().nonnegative(),
+        devices: nexusCloudDeviceCountsSchema
+      }).nullable(),
+      /** Check ids added by a newer server are dropped, never a parse failure. */
+      checks: z26.array(nexusCloudStatusCheckSchema.extend({ id: z26.string() })).transform(
+        (list) => list.flatMap((c) => {
+          const id = knownCheckId.safeParse(c.id);
+          return id.success ? [{ ...c, id: id.data }] : [];
+        })
+      ),
+      /** A verdict added by a newer server reads as `attention`: never `ok` by accident. */
+      verdict: z26.enum(NEXUS_STATUS_VERDICTS).catch("attention")
+    });
+  }
+});
+
 // packages/contracts/src/task-id.ts
 var init_task_id = __esm({
   "packages/contracts/src/task-id.ts"() {
@@ -17753,6 +17957,7 @@ var init_src = __esm({
     init_decide();
     init_decide_sites();
     init_nexus_account();
+    init_nexus_cloud();
     init_task_id();
   }
 });
@@ -31773,7 +31978,7 @@ function resolveRef(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z26.never();
+      return z27.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -31795,7 +32000,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z26.lazy(() => {
+      return z27.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -31812,25 +32017,25 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z26.null();
+      return z27.null();
     }
     if (enumValues.length === 0) {
-      return z26.never();
+      return z27.never();
     }
     if (enumValues.length === 1) {
-      return z26.literal(enumValues[0]);
+      return z27.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z26.enum(enumValues);
+      return z27.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z26.literal(v));
+    const literalSchemas = enumValues.map((v) => z27.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z26.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z27.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z26.literal(schema.const);
+    return z27.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -31839,68 +32044,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z26.never();
+      return z27.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z26.union(typeSchemas);
+    return z27.union(typeSchemas);
   }
   if (!type) {
-    return z26.any();
+    return z27.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z26.string();
+      let stringSchema = z27.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z26.email());
+          stringSchema = stringSchema.check(z27.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z26.url());
+          stringSchema = stringSchema.check(z27.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z26.uuid());
+          stringSchema = stringSchema.check(z27.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z26.iso.datetime());
+          stringSchema = stringSchema.check(z27.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z26.iso.date());
+          stringSchema = stringSchema.check(z27.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z26.iso.time());
+          stringSchema = stringSchema.check(z27.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z26.iso.duration());
+          stringSchema = stringSchema.check(z27.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z26.ipv4());
+          stringSchema = stringSchema.check(z27.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z26.ipv6());
+          stringSchema = stringSchema.check(z27.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z26.mac());
+          stringSchema = stringSchema.check(z27.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z26.cidrv4());
+          stringSchema = stringSchema.check(z27.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z26.cidrv6());
+          stringSchema = stringSchema.check(z27.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z26.base64());
+          stringSchema = stringSchema.check(z27.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z26.base64url());
+          stringSchema = stringSchema.check(z27.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z26.e164());
+          stringSchema = stringSchema.check(z27.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z26.jwt());
+          stringSchema = stringSchema.check(z27.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z26.emoji());
+          stringSchema = stringSchema.check(z27.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z26.nanoid());
+          stringSchema = stringSchema.check(z27.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z26.cuid());
+          stringSchema = stringSchema.check(z27.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z26.cuid2());
+          stringSchema = stringSchema.check(z27.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z26.ulid());
+          stringSchema = stringSchema.check(z27.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z26.xid());
+          stringSchema = stringSchema.check(z27.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z26.ksuid());
+          stringSchema = stringSchema.check(z27.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -31917,7 +32122,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z26.number().int() : z26.number();
+      let numberSchema = type === "integer" ? z27.number().int() : z27.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -31941,11 +32146,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z26.boolean();
+      zodSchema2 = z27.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z26.null();
+      zodSchema2 = z27.null();
       break;
     }
     case "object": {
@@ -31958,14 +32163,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z26.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z27.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z26.record(keySchema, valueSchema);
+          zodSchema2 = z27.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z26.object(shape).passthrough();
-        const recordSchema = z26.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z26.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z27.object(shape).passthrough();
+        const recordSchema = z27.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z27.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -31974,28 +32179,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z26.string().regex(new RegExp(pattern));
-          looseRecords.push(z26.looseRecord(keySchema, patternValue));
+          const keySchema = z27.string().regex(new RegExp(pattern));
+          looseRecords.push(z27.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z26.object(shape).passthrough());
+          schemasToIntersect.push(z27.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z26.object({}).passthrough();
+          zodSchema2 = z27.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z26.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z27.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z26.intersection(result, schemasToIntersect[i]);
+            result = z27.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z26.object(shape);
+      const objectSchema = z27.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -32012,33 +32217,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z26.tuple(tupleItems).rest(rest);
+          zodSchema2 = z27.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z26.tuple(tupleItems);
+          zodSchema2 = z27.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z26.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z27.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z26.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z27.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z26.tuple(tupleItems).rest(rest);
+          zodSchema2 = z27.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z26.tuple(tupleItems);
+          zodSchema2 = z27.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z26.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z27.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z26.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z27.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z26.array(element);
+        let arraySchema = z27.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -32047,7 +32252,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z26.array(z26.any());
+        zodSchema2 = z27.array(z27.any());
       }
       break;
     }
@@ -32064,37 +32269,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z26.any() : z26.never();
+    return schema ? z27.any() : z27.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z26.union(options);
-    baseSchema = hasExplicitType ? z26.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z27.union(options);
+    baseSchema = hasExplicitType ? z27.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z26.xor(options);
-    baseSchema = hasExplicitType ? z26.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z27.xor(options);
+    baseSchema = hasExplicitType ? z27.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z26.any();
+      baseSchema = hasExplicitType ? baseSchema : z27.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z26.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z27.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z26.nullable(baseSchema);
+    baseSchema = z27.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z26.readonly(baseSchema);
+    baseSchema = z27.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -32121,7 +32326,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z26.any() : z26.never();
+    return schema ? z27.any() : z27.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -32135,14 +32340,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z26, RECOGNIZED_KEYS;
+var z27, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
   "node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js"() {
     init_registries();
     init_checks2();
     init_iso();
     init_schemas2();
-    z26 = {
+    z27 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports