@cleocode/adapters 2026.5.120 → 2026.5.122

package/dist/index.js

@@ -786,7 +786,7 @@ var init_branch_lock = __esm({
 
 // packages/contracts/src/changesets.ts
 import { z as z3 } from "zod";
-var CHANGESET_KINDS, TASK_ID_RE, ChangesetEntrySchema;
+var CHANGESET_KINDS, CHANGESET_RELEASE_NOTE_SECTIONS, CHANGESET_RELEASE_NOTE_AUDIENCES, CHANGESET_RELEASE_NOTE_SCOPES, nonEmptyReleaseNoteText, nonEmptyReleaseNoteList, ChangesetReleaseNotesMetadataSchema, TASK_ID_RE, ChangesetEntrySchema;
 var init_changesets = __esm({
   "packages/contracts/src/changesets.ts"() {
     "use strict";
@@ -800,10 +800,60 @@ var init_changesets = __esm({
       "chore",
       "breaking"
     ];
+    CHANGESET_RELEASE_NOTE_SECTIONS = [
+      "added",
+      "changed",
+      "fixed",
+      "deprecated",
+      "removed",
+      "security",
+      "breaking"
+    ];
+    CHANGESET_RELEASE_NOTE_AUDIENCES = [
+      "users",
+      "operators",
+      "developers",
+      "maintainers"
+    ];
+    CHANGESET_RELEASE_NOTE_SCOPES = [
+      "project",
+      "package",
+      "component",
+      "docs",
+      "ops",
+      "security"
+    ];
+    nonEmptyReleaseNoteText = z3.string().min(1, "release-note metadata text must be non-empty");
+    nonEmptyReleaseNoteList = z3.array(nonEmptyReleaseNoteText).min(1, "release-note metadata list must contain at least one item");
+    ChangesetReleaseNotesMetadataSchema = z3.object({
+      /** Keep-a-Changelog style section/category override. */
+      section: z3.enum(CHANGESET_RELEASE_NOTE_SECTIONS).optional(),
+      /** Intended readers for the note. */
+      audience: z3.array(z3.enum(CHANGESET_RELEASE_NOTE_AUDIENCES)).min(1).optional(),
+      /** Release-note scope. */
+      scope: z3.enum(CHANGESET_RELEASE_NOTE_SCOPES).optional(),
+      /** Package/project/component targets affected by this entry. */
+      targets: nonEmptyReleaseNoteList.optional(),
+      /** User- or operator-visible impact statement. */
+      impact: nonEmptyReleaseNoteText.optional(),
+      /** Deterministic migration/action text, separate from breaking changes. */
+      migration: nonEmptyReleaseNoteText.optional(),
+      /** Deprecation detail for Deprecated sections. */
+      deprecation: nonEmptyReleaseNoteText.optional(),
+      /** Security detail for Security sections. */
+      security: nonEmptyReleaseNoteText.optional(),
+      /** Operator-facing rollout/verification note. */
+      operatorNotes: nonEmptyReleaseNoteText.optional(),
+      /** Explicit inclusion toggle for future release-scope filters. */
+      includeInChangelog: z3.boolean().optional()
+    }).strict();
     TASK_ID_RE = /^(T\d+(-[A-Z][A-Za-z0-9]*)?|E-\d+(-[A-Z][A-Za-z0-9]*)?)$/;
     ChangesetEntrySchema = z3.object({
-      /** Filename slug (without the `.md` extension). */
-      id: z3.string().min(1, "id must be non-empty").regex(/^[a-z0-9][a-z0-9-]*$/, "id must be kebab-case (lowercase, digits, hyphens)"),
+      /** Filename identifier (without the `.md` extension); lowercase kebab-case for new files, legacy uppercase task IDs accepted. */
+      id: z3.string().min(1, "id must be non-empty").regex(
+        /^[A-Za-z0-9][A-Za-z0-9-]*$/,
+        "id must contain only ASCII letters, digits, and hyphens"
+      ),
       /** One or more CLEO task IDs this change is anchored to. */
       tasks: z3.array(z3.string().regex(TASK_ID_RE, "task ID must match T#### or E-#### format")).min(1, "tasks must contain at least one task ID"),
       /** Type of change. */
@@ -815,7 +865,9 @@ var init_changesets = __esm({
       /** Markdown body — longer-form explanation. */
       notes: z3.string().optional(),
       /** Migration note. Required iff `kind === 'breaking'`. */
-      breaking: z3.string().optional()
+      breaking: z3.string().optional(),
+      /** Structured author-provided metadata for deterministic release notes. */
+      releaseNotes: ChangesetReleaseNotesMetadataSchema.optional()
     }).refine((entry) => entry.kind !== "breaking" || (entry.breaking?.length ?? 0) > 0, {
       message: "breaking entries must include a non-empty `breaking` migration note",
       path: ["breaking"]
@@ -1359,7 +1411,7 @@ var init_errors = __esm({
 
 // packages/contracts/src/evidence-atom-schema.ts
 import { z as z6 } from "zod";
-var commitAtomSchema, filesAtomSchema, testRunAtomSchema, toolAtomSchema, urlAtomSchema, noteAtomSchema, decisionAtomSchema, prAtomSchema, locDropAtomSchema, callsiteCoverageAtomSchema, EvidenceAtomSchema, GATE_EVIDENCE_REQUIREMENTS;
+var commitAtomSchema, filesAtomSchema, testRunAtomSchema, toolAtomSchema, urlAtomSchema, noteAtomSchema, decisionAtomSchema, prAtomSchema, locDropAtomSchema, callsiteCoverageAtomSchema, AC_UUID_REGEX, AC_ALIAS_REGEX, SATISFIES_TASK_ID_REGEX, SATISFIES_VERSION_PIN_REGEX, satisfiesAtomSchema, EvidenceAtomSchema, GATE_EVIDENCE_REQUIREMENTS, ATOM_EXAMPLES;
 var init_evidence_atom_schema = __esm({
   "packages/contracts/src/evidence-atom-schema.ts"() {
     "use strict";
@@ -1405,6 +1457,24 @@ var init_evidence_atom_schema = __esm({
       symbolName: z6.string().min(1, "callsite-coverage atom requires a non-empty symbolName"),
       relativeSourcePath: z6.string().min(1, "callsite-coverage atom requires a non-empty relativeSourcePath")
     });
+    AC_UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+    AC_ALIAS_REGEX = /^AC[0-9]{1,4}$/;
+    SATISFIES_TASK_ID_REGEX = /^T[0-9]{1,7}$/;
+    SATISFIES_VERSION_PIN_REGEX = /^[0-9]{14}$/;
+    satisfiesAtomSchema = z6.object({
+      kind: z6.literal("satisfies"),
+      /** Target task ID — `T<1-7 digits>` per ADR-079-r2 §2.1. */
+      targetTaskId: z6.string().regex(SATISFIES_TASK_ID_REGEX, "satisfies atom targetTaskId must match /^T[0-9]{1,7}$/"),
+      /** Lowercase UUIDv4 — populated for the canonical form; undefined for alias form. */
+      targetAcId: z6.string().regex(AC_UUID_REGEX, "satisfies atom targetAcId must be a lowercase UUIDv4").optional(),
+      /** Positional alias `AC<1-4 digits>` — populated for alias form; undefined for UUID form. */
+      targetAcAlias: z6.string().regex(AC_ALIAS_REGEX, "satisfies atom targetAcAlias must match /^AC[0-9]{1,4}$/").optional(),
+      /** Optional `@<14-digit YYYYMMDDhhmmss>` pin captured at mint time. */
+      versionPin: z6.string().regex(
+        SATISFIES_VERSION_PIN_REGEX,
+        "satisfies atom versionPin must be 14 digits (YYYYMMDDhhmmss)"
+      ).optional()
+    });
     EvidenceAtomSchema = z6.discriminatedUnion("kind", [
       commitAtomSchema,
       filesAtomSchema,
@@ -1415,7 +1485,8 @@ var init_evidence_atom_schema = __esm({
       decisionAtomSchema,
       prAtomSchema,
       locDropAtomSchema,
-      callsiteCoverageAtomSchema
+      callsiteCoverageAtomSchema,
+      satisfiesAtomSchema
     ]);
     GATE_EVIDENCE_REQUIREMENTS = Object.freeze({
       implemented: {
@@ -1434,6 +1505,19 @@ var init_evidence_atom_schema = __esm({
       cleanupDone: { oneOf: [["note"]] },
       nexusImpact: { oneOf: [["tool"], ["note"]] }
     });
+    ATOM_EXAMPLES = Object.freeze({
+      commit: "commit:<sha>",
+      files: "files:path/a.ts,path/b.ts",
+      "test-run": "test-run:/tmp/vitest-out.json",
+      tool: "tool:test",
+      url: "url:https://example.com/docs",
+      note: "note:<short description>",
+      decision: "decision:D-arch-001",
+      pr: "pr:357",
+      "loc-drop": "loc-drop:<fromLines>:<toLines>",
+      "callsite-coverage": "callsite-coverage:<symbolName>:<relativeSourcePath>",
+      satisfies: "satisfies:T1234#AC2"
+    });
   }
 });
 
@@ -2710,6 +2794,52 @@ var init_manifest2 = __esm({
   }
 });
 
+// packages/contracts/src/validator/index.ts
+import { z as z14 } from "zod";
+var VALIDATOR_ID_REGEX, validatorFindingSchema, validatorAttestationSchema, validatorRejectionSchema, validatorVerdictSchema;
+var init_validator = __esm({
+  "packages/contracts/src/validator/index.ts"() {
+    "use strict";
+    VALIDATOR_ID_REGEX = /^validator-[a-z0-9][a-z0-9-]*$/;
+    validatorFindingSchema = z14.object({
+      acId: z14.string().min(1, "acId must be non-empty"),
+      status: z14.enum(["pass", "fail", "inconclusive"]),
+      reasoning: z14.string().min(1, "reasoning must be non-empty"),
+      evidenceRefs: z14.array(z14.string()).optional(),
+      checkedAt: z14.string().min(1, "checkedAt must be a non-empty ISO-8601 string")
+    });
+    validatorAttestationSchema = z14.object({
+      verdict: z14.literal("attest"),
+      taskId: z14.string().min(1),
+      validatorId: z14.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
+      findings: z14.array(validatorFindingSchema).min(1, "attestation must contain at least one finding").refine(
+        (findings) => findings.every((f) => f.status === "pass"),
+        'attestation requires every finding to have status="pass"'
+      ),
+      summary: z14.string().optional(),
+      attestedAt: z14.string().min(1),
+      schemaVersion: z14.literal("1")
+    });
+    validatorRejectionSchema = z14.object({
+      verdict: z14.literal("reject"),
+      taskId: z14.string().min(1),
+      validatorId: z14.string().regex(VALIDATOR_ID_REGEX, "validatorId must match the pattern validator-<discriminator>"),
+      findings: z14.array(validatorFindingSchema).min(1, "rejection must contain at least one finding").refine(
+        (findings) => findings.some((f) => f.status !== "pass"),
+        'rejection requires at least one finding with status "fail" or "inconclusive"'
+      ),
+      summary: z14.string().min(1, "rejection summary must be non-empty"),
+      remediationHints: z14.array(z14.string()).optional(),
+      rejectedAt: z14.string().min(1),
+      schemaVersion: z14.literal("1")
+    });
+    validatorVerdictSchema = z14.discriminatedUnion("verdict", [
+      validatorAttestationSchema,
+      validatorRejectionSchema
+    ]);
+  }
+});
+
 // packages/contracts/src/index.ts
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
@@ -2753,6 +2883,7 @@ var init_src = __esm({
     init_task_evidence();
     init_archive();
     init_manifest2();
+    init_validator();
   }
 });
 
@@ -16772,7 +16903,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 z14.never();
+      return z15.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -16794,7 +16925,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z14.lazy(() => {
+      return z15.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -16811,25 +16942,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 z14.null();
+      return z15.null();
     }
     if (enumValues.length === 0) {
-      return z14.never();
+      return z15.never();
     }
     if (enumValues.length === 1) {
-      return z14.literal(enumValues[0]);
+      return z15.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z14.enum(enumValues);
+      return z15.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z14.literal(v));
+    const literalSchemas = enumValues.map((v) => z15.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z14.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z15.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z14.literal(schema.const);
+    return z15.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -16838,68 +16969,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z14.never();
+      return z15.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z14.union(typeSchemas);
+    return z15.union(typeSchemas);
   }
   if (!type) {
-    return z14.any();
+    return z15.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z14.string();
+      let stringSchema = z15.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z14.email());
+          stringSchema = stringSchema.check(z15.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z14.url());
+          stringSchema = stringSchema.check(z15.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z14.uuid());
+          stringSchema = stringSchema.check(z15.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z14.iso.datetime());
+          stringSchema = stringSchema.check(z15.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z14.iso.date());
+          stringSchema = stringSchema.check(z15.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z14.iso.time());
+          stringSchema = stringSchema.check(z15.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z14.iso.duration());
+          stringSchema = stringSchema.check(z15.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z14.ipv4());
+          stringSchema = stringSchema.check(z15.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z14.ipv6());
+          stringSchema = stringSchema.check(z15.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z14.mac());
+          stringSchema = stringSchema.check(z15.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z14.cidrv4());
+          stringSchema = stringSchema.check(z15.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z14.cidrv6());
+          stringSchema = stringSchema.check(z15.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z14.base64());
+          stringSchema = stringSchema.check(z15.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z14.base64url());
+          stringSchema = stringSchema.check(z15.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z14.e164());
+          stringSchema = stringSchema.check(z15.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z14.jwt());
+          stringSchema = stringSchema.check(z15.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z14.emoji());
+          stringSchema = stringSchema.check(z15.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z14.nanoid());
+          stringSchema = stringSchema.check(z15.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z14.cuid());
+          stringSchema = stringSchema.check(z15.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z14.cuid2());
+          stringSchema = stringSchema.check(z15.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z14.ulid());
+          stringSchema = stringSchema.check(z15.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z14.xid());
+          stringSchema = stringSchema.check(z15.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z14.ksuid());
+          stringSchema = stringSchema.check(z15.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -16916,7 +17047,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z14.number().int() : z14.number();
+      let numberSchema = type === "integer" ? z15.number().int() : z15.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -16940,11 +17071,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z14.boolean();
+      zodSchema2 = z15.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z14.null();
+      zodSchema2 = z15.null();
       break;
     }
     case "object": {
@@ -16957,14 +17088,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) : z14.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z15.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z14.record(keySchema, valueSchema);
+          zodSchema2 = z15.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z14.object(shape).passthrough();
-        const recordSchema = z14.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z14.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z15.object(shape).passthrough();
+        const recordSchema = z15.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z15.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -16973,28 +17104,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z14.string().regex(new RegExp(pattern));
-          looseRecords.push(z14.looseRecord(keySchema, patternValue));
+          const keySchema = z15.string().regex(new RegExp(pattern));
+          looseRecords.push(z15.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z14.object(shape).passthrough());
+          schemasToIntersect.push(z15.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z14.object({}).passthrough();
+          zodSchema2 = z15.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z14.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z15.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z14.intersection(result, schemasToIntersect[i]);
+            result = z15.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z14.object(shape);
+      const objectSchema = z15.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -17011,33 +17142,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 = z14.tuple(tupleItems).rest(rest);
+          zodSchema2 = z15.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z14.tuple(tupleItems);
+          zodSchema2 = z15.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z14.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z15.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z14.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z15.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 = z14.tuple(tupleItems).rest(rest);
+          zodSchema2 = z15.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z14.tuple(tupleItems);
+          zodSchema2 = z15.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z14.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z15.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z14.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z15.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z14.array(element);
+        let arraySchema = z15.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -17046,7 +17177,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z14.array(z14.any());
+        zodSchema2 = z15.array(z15.any());
       }
       break;
     }
@@ -17063,37 +17194,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z14.any() : z14.never();
+    return schema ? z15.any() : z15.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 = z14.union(options);
-    baseSchema = hasExplicitType ? z14.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z15.union(options);
+    baseSchema = hasExplicitType ? z15.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z14.xor(options);
-    baseSchema = hasExplicitType ? z14.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z15.xor(options);
+    baseSchema = hasExplicitType ? z15.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z14.any();
+      baseSchema = hasExplicitType ? baseSchema : z15.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 = z14.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z15.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z14.nullable(baseSchema);
+    baseSchema = z15.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z14.readonly(baseSchema);
+    baseSchema = z15.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -17120,7 +17251,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z14.any() : z14.never();
+    return schema ? z15.any() : z15.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -17134,14 +17265,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z14, RECOGNIZED_KEYS;
+var z15, 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();
-    z14 = {
+    z15 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports