@cleocode/adapters 2026.5.77 → 2026.5.79

package/dist/index.js

@@ -790,10 +790,13 @@ function parseClaudeCodeCredentials(buf) {
     const expiresAt = typeof block["expiresAt"] === "number" ? block["expiresAt"] : void 0;
     if (expiresAt !== void 0 && Date.now() > expiresAt) return null;
     const refreshToken = typeof block["refreshToken"] === "string" && block["refreshToken"].trim() ? block["refreshToken"] : void 0;
+    const rawScopes = block["scopes"];
+    const scopes = Array.isArray(rawScopes) && rawScopes.every((s) => typeof s === "string") ? rawScopes : void 0;
     return {
       accessToken: accessToken.trim(),
       ...expiresAt !== void 0 ? { expiresAt } : {},
-      ...refreshToken !== void 0 ? { refreshToken } : {}
+      ...refreshToken !== void 0 ? { refreshToken } : {},
+      ...scopes !== void 0 ? { scopes } : {}
     };
   } catch {
     return null;
@@ -1166,6 +1169,192 @@ var init_peer = __esm({
   }
 });
 
+// packages/contracts/src/release/plan.ts
+import { z as z4 } from "zod";
+var RELEASE_CHANNEL, RELEASE_SCHEME, RELEASE_KIND, RELEASE_STATUS, GATE_STATUS, GATE_NAME, PLATFORM_TUPLE, PUBLISHER, TASK_KIND, IMPACT, RESOLVED_SOURCE, ReleaseChannelSchema, ReleaseSchemeSchema, ReleaseKindSchema, ReleaseStatusSchema, GateStatusSchema, GateNameSchema, PlatformTupleSchema, PublisherSchema, TaskKindSchema, ImpactSchema, ResolvedSourceSchema, Iso8601, NonEmptyString, ReleasePlanTaskSchema, ReleaseGateSchema, ReleasePlatformMatrixEntrySchema, ReleasePreflightSummarySchema, ReleasePlanChangelogSchema, ReleasePlanMetaSchema, ReleasePlanSchema;
+var init_plan = __esm({
+  "packages/contracts/src/release/plan.ts"() {
+    "use strict";
+    RELEASE_CHANNEL = ["latest", "beta", "alpha", "rc"];
+    RELEASE_SCHEME = ["calver", "semver", "calver-suffix"];
+    RELEASE_KIND = ["regular", "hotfix", "prerelease"];
+    RELEASE_STATUS = [
+      "planned",
+      "pr-opened",
+      "pr-merged",
+      "published",
+      "reconciled",
+      "rolled_back",
+      "failed",
+      "cancelled"
+    ];
+    GATE_STATUS = ["passed", "failed", "skipped", "unresolved"];
+    GATE_NAME = ["test", "build", "lint", "typecheck", "audit", "security-scan"];
+    PLATFORM_TUPLE = [
+      "linux-x64",
+      "linux-arm64",
+      "macos-x64",
+      "macos-arm64",
+      "windows-x64",
+      "any"
+    ];
+    PUBLISHER = ["npm", "cargo", "docker", "pypi", "github-release", "binary"];
+    TASK_KIND = [
+      "feat",
+      "fix",
+      "chore",
+      "docs",
+      "refactor",
+      "test",
+      "perf",
+      "revert",
+      "breaking",
+      "hotfix"
+    ];
+    IMPACT = ["major", "minor", "patch"];
+    RESOLVED_SOURCE = ["project-context", "language-default", "legacy-alias"];
+    ReleaseChannelSchema = z4.enum(RELEASE_CHANNEL);
+    ReleaseSchemeSchema = z4.enum(RELEASE_SCHEME);
+    ReleaseKindSchema = z4.enum(RELEASE_KIND);
+    ReleaseStatusSchema = z4.enum(RELEASE_STATUS);
+    GateStatusSchema = z4.enum(GATE_STATUS);
+    GateNameSchema = z4.enum(GATE_NAME);
+    PlatformTupleSchema = z4.enum(PLATFORM_TUPLE);
+    PublisherSchema = z4.enum(PUBLISHER);
+    TaskKindSchema = z4.enum(TASK_KIND);
+    ImpactSchema = z4.enum(IMPACT);
+    ResolvedSourceSchema = z4.enum(RESOLVED_SOURCE);
+    Iso8601 = z4.iso.datetime({ offset: true });
+    NonEmptyString = z4.string().min(1);
+    ReleasePlanTaskSchema = z4.object({
+      /** Task ID (e.g. "T10001"). Format intentionally loose so historical IDs validate. */
+      id: NonEmptyString,
+      /** Conventional-commit-aligned task classification. */
+      kind: TaskKindSchema,
+      /** SemVer impact classification. */
+      impact: ImpactSchema,
+      /** Human-readable changelog line for this task. */
+      userFacingSummary: z4.string(),
+      /**
+       * ADR-051 evidence atoms attesting the task's gate results. Format is
+       * `kind:value` (e.g. `commit:abc123`, `test-run:vitest.json`). The contract
+       * accepts empty arrays so legacy plans validate; `cleo release plan`
+       * enforces non-empty via R-301.
+       */
+      evidenceAtoms: z4.array(NonEmptyString),
+      /** IVTR phase at plan time — informational only per R-316. */
+      ivtrPhaseAtPlan: z4.string().optional(),
+      /** Epic this task rolls up to, locked at plan time per R-303. */
+      epicAncestor: NonEmptyString
+    });
+    ReleaseGateSchema = z4.object({
+      /** Canonical gate name. */
+      name: GateNameSchema,
+      /** ADR-051 atom string identifying the resolved tool (e.g. `tool:test`). */
+      atom: NonEmptyString,
+      /** Gate execution status at plan time. */
+      status: GateStatusSchema,
+      /** ISO-8601 timestamp the gate was last verified. */
+      lastVerifiedAt: Iso8601,
+      /** Resolved shell command (e.g. `pnpm run test`). Optional for unresolved gates. */
+      resolvedCommand: z4.string().optional(),
+      /** Provenance of the resolved command. Optional for unresolved gates. */
+      resolvedSource: ResolvedSourceSchema.optional()
+    });
+    ReleasePlatformMatrixEntrySchema = z4.object({
+      /** Target platform tuple. */
+      platform: PlatformTupleSchema,
+      /** Distribution backend. */
+      publisher: PublisherSchema,
+      /** Package identifier on the target backend (e.g. `@cleocode/cleo`). */
+      package: NonEmptyString,
+      /** Whether to run the GHA smoke job for this matrix entry. */
+      smoke: z4.boolean().default(true).optional()
+    });
+    ReleasePreflightSummarySchema = z4.object({
+      /** True if esbuild externals are out of sync with package.json. */
+      esbuildExternalsDrift: z4.boolean(),
+      /** True if `pnpm-lock.yaml` diverges from the workspace manifest. */
+      lockfileDrift: z4.boolean(),
+      /** True if all epic children are in terminal lifecycle states. */
+      epicCompletenessClean: z4.boolean(),
+      /** True if no task appears in multiple in-flight release plans. */
+      doubleListingClean: z4.boolean(),
+      /** Non-fatal preflight warnings (e.g. unresolved tools per R-024). */
+      preflightWarnings: z4.array(z4.string()).default([]).optional()
+    });
+    ReleasePlanChangelogSchema = z4.object({
+      /** `kind=feat` tasks. */
+      features: z4.array(NonEmptyString).default([]),
+      /** `kind=fix` or `kind=hotfix` tasks. */
+      fixes: z4.array(NonEmptyString).default([]),
+      /** `kind=chore`, `docs`, `refactor`, `test`, `perf` tasks. */
+      chores: z4.array(NonEmptyString).default([]),
+      /** `kind=breaking` or `kind=revert` tasks. */
+      breaking: z4.array(NonEmptyString).default([])
+    });
+    ReleasePlanMetaSchema = z4.object({
+      /** True if this is the project's first ever release. */
+      firstEverRelease: z4.boolean().optional(),
+      /** Canonical tool names that could not be resolved at plan time. */
+      unresolvedTools: z4.array(z4.string()).optional(),
+      /** Project archetype detected at plan time. */
+      archetype: z4.string().optional()
+    }).catchall(z4.unknown());
+    ReleasePlanSchema = z4.object({
+      /** Schema URL for this plan version. */
+      $schema: z4.string().optional(),
+      /** Requested version string (e.g. "v2026.6.0"). Includes the leading `v`. */
+      version: NonEmptyString,
+      /** Resolved version string after suffix application (e.g. "v2026.6.0.2"). */
+      resolvedVersion: NonEmptyString,
+      /** True if a `calver-suffix` was applied to disambiguate a same-day hotfix. */
+      suffixApplied: z4.boolean(),
+      /** Versioning scheme governing `version` / `resolvedVersion`. */
+      scheme: ReleaseSchemeSchema,
+      /** npm dist-tag channel for this release. */
+      channel: ReleaseChannelSchema,
+      /** Epic ID this release ships. */
+      epicId: NonEmptyString,
+      /** Release-kind classification. */
+      releaseKind: ReleaseKindSchema,
+      /** ISO-8601 timestamp the plan was written. */
+      createdAt: Iso8601,
+      /** Identifier of the actor that wrote the plan (agent name or operator). */
+      createdBy: NonEmptyString,
+      /**
+       * Version of the previous release on the same channel. MUST be `null` only
+       * for first-ever releases (R-300, enforced at the verb layer).
+       */
+      previousVersion: z4.string().nullable(),
+      /** Git tag of the previous release (typically `previousVersion` prefixed). */
+      previousTag: z4.string().nullable(),
+      /** ISO-8601 timestamp the previous release was published. */
+      previousShippedAt: Iso8601.nullable(),
+      /** Tasks rolled into this release. */
+      tasks: z4.array(ReleasePlanTaskSchema),
+      /** Bucketed changelog. */
+      changelog: ReleasePlanChangelogSchema,
+      /** Per-gate verification status. */
+      gates: z4.array(ReleaseGateSchema),
+      /** Platform / publisher matrix. */
+      platformMatrix: z4.array(ReleasePlatformMatrixEntrySchema),
+      /** Preflight summary from `cleo release plan`. */
+      preflightSummary: ReleasePreflightSummarySchema,
+      /** URL of the GHA workflow run (populated by `release-prepare.yml`). */
+      workflowRunUrl: z4.string().nullable(),
+      /** URL of the bump PR (populated by `cleo release open`). */
+      prUrl: z4.string().nullable(),
+      /** Merge commit SHA on `main` (populated by `release-publish.yml`). */
+      mergeCommitSha: z4.string().nullable(),
+      /** Current FSM state per R-302. */
+      status: ReleaseStatusSchema,
+      /** Informational / forward-compat metadata. */
+      meta: ReleasePlanMetaSchema.optional()
+    });
+  }
+});
+
 // packages/contracts/src/session.ts
 var init_session2 = __esm({
   "packages/contracts/src/session.ts"() {
@@ -1174,52 +1363,52 @@ var init_session2 = __esm({
 });
 
 // packages/contracts/src/session-journal.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var SESSION_JOURNAL_SCHEMA_VERSION, sessionJournalDoctorSummarySchema, sessionJournalDebriefSummarySchema, sessionJournalEntrySchema;
 var init_session_journal = __esm({
   "packages/contracts/src/session-journal.ts"() {
     "use strict";
     SESSION_JOURNAL_SCHEMA_VERSION = "1.0";
-    sessionJournalDoctorSummarySchema = z4.object({
+    sessionJournalDoctorSummarySchema = z5.object({
       /** `true` when zero noise patterns were detected. */
-      isClean: z4.boolean(),
+      isClean: z5.boolean(),
       /** Total number of noise findings across all patterns. */
-      findingsCount: z4.number().int().nonnegative(),
+      findingsCount: z5.number().int().nonnegative(),
       /** Pattern names that were detected (empty when isClean). */
-      patterns: z4.array(z4.string()),
+      patterns: z5.array(z5.string()),
       /** Total brain entries scanned. `0` = empty or unavailable. */
-      totalScanned: z4.number().int().nonnegative()
+      totalScanned: z5.number().int().nonnegative()
     });
-    sessionJournalDebriefSummarySchema = z4.object({
+    sessionJournalDebriefSummarySchema = z5.object({
       /** First 200 characters of the session end note (if provided). */
-      noteExcerpt: z4.string().max(200).optional(),
+      noteExcerpt: z5.string().max(200).optional(),
       /** Number of tasks completed during the session. */
-      tasksCompletedCount: z4.number().int().nonnegative(),
+      tasksCompletedCount: z5.number().int().nonnegative(),
       /** Up to 5 task IDs (not titles) that were the focus of the session. */
-      tasksFocused: z4.array(z4.string()).max(5).optional()
+      tasksFocused: z5.array(z5.string()).max(5).optional()
     });
-    sessionJournalEntrySchema = z4.object({
+    sessionJournalEntrySchema = z5.object({
       // Identity
       /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
-      schemaVersion: z4.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      schemaVersion: z5.literal(SESSION_JOURNAL_SCHEMA_VERSION),
       /** ISO 8601 timestamp when the entry was written. */
-      timestamp: z4.string(),
+      timestamp: z5.string(),
       /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
-      sessionId: z4.string(),
+      sessionId: z5.string(),
       /** Event type that triggered this journal entry. */
-      eventType: z4.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      eventType: z5.enum(["session_start", "session_end", "observation", "decision", "error"]),
       // Session metadata (set on session_start / session_end)
       /** Agent identifier (e.g. `cleo-prime`, `claude-code`). */
-      agentIdentifier: z4.string().optional(),
+      agentIdentifier: z5.string().optional(),
       /** Provider adapter ID active for this session. */
-      providerId: z4.string().optional(),
+      providerId: z5.string().optional(),
       /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
-      scope: z4.string().optional(),
+      scope: z5.string().optional(),
       // Session-end fields
       /** Duration of the session in seconds (session_end only). */
-      duration: z4.number().int().nonnegative().optional(),
+      duration: z5.number().int().nonnegative().optional(),
       /** Task IDs (not titles) completed during the session. */
-      tasksCompleted: z4.array(z4.string()).optional(),
+      tasksCompleted: z5.array(z5.string()).optional(),
       // Doctor summary (T1262 absorbed)
       /** Compact result of `scanBrainNoise` run at session-end. */
       doctorSummary: sessionJournalDoctorSummarySchema.optional(),
@@ -1228,7 +1417,7 @@ var init_session_journal = __esm({
       debriefSummary: sessionJournalDebriefSummarySchema.optional(),
       // Optional hash chain
       /** SHA-256 hex of the previous entry's raw JSON string (for integrity chain). */
-      prevEntryHash: z4.string().optional()
+      prevEntryHash: z5.string().optional()
     });
   }
 });
@@ -1248,52 +1437,52 @@ var init_task = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z5.object({
-      kind: z5.literal("file"),
-      sha256: z5.string().length(64),
-      timestamp: z5.string().datetime(),
-      path: z5.string().min(1),
-      mime: z5.string().optional(),
-      description: z5.string().optional()
-    });
-    logEvidenceSchema = z5.object({
-      kind: z5.literal("log"),
-      sha256: z5.string().length(64),
-      timestamp: z5.string().datetime(),
-      source: z5.string().min(1),
-      description: z5.string().optional()
-    });
-    screenshotEvidenceSchema = z5.object({
-      kind: z5.literal("screenshot"),
-      sha256: z5.string().length(64),
-      timestamp: z5.string().datetime(),
-      mime: z5.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z5.string().optional()
-    });
-    testOutputEvidenceSchema = z5.object({
-      kind: z5.literal("test-output"),
-      sha256: z5.string().length(64),
-      timestamp: z5.string().datetime(),
-      passed: z5.number().int().nonnegative(),
-      failed: z5.number().int().nonnegative(),
-      skipped: z5.number().int().nonnegative(),
-      exitCode: z5.number().int(),
-      description: z5.string().optional()
-    });
-    commandOutputEvidenceSchema = z5.object({
-      kind: z5.literal("command-output"),
-      sha256: z5.string().length(64),
-      timestamp: z5.string().datetime(),
-      cmd: z5.string().min(1),
-      exitCode: z5.number().int(),
-      description: z5.string().optional()
-    });
-    taskEvidenceSchema = z5.discriminatedUnion("kind", [
+    fileEvidenceSchema = z6.object({
+      kind: z6.literal("file"),
+      sha256: z6.string().length(64),
+      timestamp: z6.string().datetime(),
+      path: z6.string().min(1),
+      mime: z6.string().optional(),
+      description: z6.string().optional()
+    });
+    logEvidenceSchema = z6.object({
+      kind: z6.literal("log"),
+      sha256: z6.string().length(64),
+      timestamp: z6.string().datetime(),
+      source: z6.string().min(1),
+      description: z6.string().optional()
+    });
+    screenshotEvidenceSchema = z6.object({
+      kind: z6.literal("screenshot"),
+      sha256: z6.string().length(64),
+      timestamp: z6.string().datetime(),
+      mime: z6.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
+      description: z6.string().optional()
+    });
+    testOutputEvidenceSchema = z6.object({
+      kind: z6.literal("test-output"),
+      sha256: z6.string().length(64),
+      timestamp: z6.string().datetime(),
+      passed: z6.number().int().nonnegative(),
+      failed: z6.number().int().nonnegative(),
+      skipped: z6.number().int().nonnegative(),
+      exitCode: z6.number().int(),
+      description: z6.string().optional()
+    });
+    commandOutputEvidenceSchema = z6.object({
+      kind: z6.literal("command-output"),
+      sha256: z6.string().length(64),
+      timestamp: z6.string().datetime(),
+      cmd: z6.string().min(1),
+      exitCode: z6.number().int(),
+      description: z6.string().optional()
+    });
+    taskEvidenceSchema = z6.discriminatedUnion("kind", [
       fileEvidenceSchema,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -1304,12 +1493,12 @@ var init_task_evidence = __esm({
 });
 
 // packages/contracts/src/tasks/archive.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var ArchiveReason, ARCHIVE_REASON_VALUES;
 var init_archive = __esm({
   "packages/contracts/src/tasks/archive.ts"() {
     "use strict";
-    ArchiveReason = z6.enum([
+    ArchiveReason = z7.enum([
       "verified",
       "reconciled",
       "superseded",
@@ -1340,6 +1529,7 @@ var init_src = __esm({
     init_nexus_scope_map();
     init_params();
     init_peer();
+    init_plan();
     init_session2();
     init_session_journal();
     init_status_registry();
@@ -15365,7 +15555,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 z7.never();
+      return z8.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -15387,7 +15577,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z7.lazy(() => {
+      return z8.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -15404,25 +15594,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 z7.null();
+      return z8.null();
     }
     if (enumValues.length === 0) {
-      return z7.never();
+      return z8.never();
     }
     if (enumValues.length === 1) {
-      return z7.literal(enumValues[0]);
+      return z8.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z7.enum(enumValues);
+      return z8.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z7.literal(v));
+    const literalSchemas = enumValues.map((v) => z8.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z7.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z8.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z7.literal(schema.const);
+    return z8.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -15431,68 +15621,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z7.never();
+      return z8.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z7.union(typeSchemas);
+    return z8.union(typeSchemas);
   }
   if (!type) {
-    return z7.any();
+    return z8.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z7.string();
+      let stringSchema = z8.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z7.email());
+          stringSchema = stringSchema.check(z8.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z7.url());
+          stringSchema = stringSchema.check(z8.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z7.uuid());
+          stringSchema = stringSchema.check(z8.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z7.iso.datetime());
+          stringSchema = stringSchema.check(z8.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z7.iso.date());
+          stringSchema = stringSchema.check(z8.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z7.iso.time());
+          stringSchema = stringSchema.check(z8.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z7.iso.duration());
+          stringSchema = stringSchema.check(z8.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z7.ipv4());
+          stringSchema = stringSchema.check(z8.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z7.ipv6());
+          stringSchema = stringSchema.check(z8.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z7.mac());
+          stringSchema = stringSchema.check(z8.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z7.cidrv4());
+          stringSchema = stringSchema.check(z8.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z7.cidrv6());
+          stringSchema = stringSchema.check(z8.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z7.base64());
+          stringSchema = stringSchema.check(z8.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z7.base64url());
+          stringSchema = stringSchema.check(z8.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z7.e164());
+          stringSchema = stringSchema.check(z8.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z7.jwt());
+          stringSchema = stringSchema.check(z8.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z7.emoji());
+          stringSchema = stringSchema.check(z8.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z7.nanoid());
+          stringSchema = stringSchema.check(z8.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z7.cuid());
+          stringSchema = stringSchema.check(z8.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z7.cuid2());
+          stringSchema = stringSchema.check(z8.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z7.ulid());
+          stringSchema = stringSchema.check(z8.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z7.xid());
+          stringSchema = stringSchema.check(z8.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z7.ksuid());
+          stringSchema = stringSchema.check(z8.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -15509,7 +15699,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z7.number().int() : z7.number();
+      let numberSchema = type === "integer" ? z8.number().int() : z8.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -15533,11 +15723,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z7.boolean();
+      zodSchema2 = z8.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z7.null();
+      zodSchema2 = z8.null();
       break;
     }
     case "object": {
@@ -15550,14 +15740,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) : z7.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z8.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z7.record(keySchema, valueSchema);
+          zodSchema2 = z8.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z7.object(shape).passthrough();
-        const recordSchema = z7.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z7.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z8.object(shape).passthrough();
+        const recordSchema = z8.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z8.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -15566,28 +15756,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z7.string().regex(new RegExp(pattern));
-          looseRecords.push(z7.looseRecord(keySchema, patternValue));
+          const keySchema = z8.string().regex(new RegExp(pattern));
+          looseRecords.push(z8.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z7.object(shape).passthrough());
+          schemasToIntersect.push(z8.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z7.object({}).passthrough();
+          zodSchema2 = z8.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z7.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z8.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z7.intersection(result, schemasToIntersect[i]);
+            result = z8.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z7.object(shape);
+      const objectSchema = z8.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -15604,33 +15794,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 = z7.tuple(tupleItems).rest(rest);
+          zodSchema2 = z8.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z7.tuple(tupleItems);
+          zodSchema2 = z8.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z7.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z8.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z7.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z8.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 = z7.tuple(tupleItems).rest(rest);
+          zodSchema2 = z8.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z7.tuple(tupleItems);
+          zodSchema2 = z8.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z7.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z8.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z7.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z8.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z7.array(element);
+        let arraySchema = z8.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -15639,7 +15829,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z7.array(z7.any());
+        zodSchema2 = z8.array(z8.any());
       }
       break;
     }
@@ -15656,37 +15846,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z7.any() : z7.never();
+    return schema ? z8.any() : z8.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 = z7.union(options);
-    baseSchema = hasExplicitType ? z7.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z8.union(options);
+    baseSchema = hasExplicitType ? z8.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z7.xor(options);
-    baseSchema = hasExplicitType ? z7.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z8.xor(options);
+    baseSchema = hasExplicitType ? z8.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z7.any();
+      baseSchema = hasExplicitType ? baseSchema : z8.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 = z7.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z8.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z7.nullable(baseSchema);
+    baseSchema = z8.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z7.readonly(baseSchema);
+    baseSchema = z8.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -15713,7 +15903,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z7.any() : z7.never();
+    return schema ? z8.any() : z8.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -15727,14 +15917,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z7, RECOGNIZED_KEYS;
+var z8, 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();
-    z7 = {
+    z8 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports