@psnext/slingcli 3.3.20260911-1 → 3.3.20260914-1

package/node_modules/zod/src/v4/classic/tests/properties.test.ts

@@ -1,25 +1,15 @@
 import { expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 
-test("z.properties is a schema", () => {
-  const p = z.properties({ a: z.literal("x"), b: z.literal("y") });
+test("z.properties is a check", () => {
+  const s = z.object({ a: z.string(), b: z.string() }).check(z.properties({ a: z.literal("x"), b: z.literal("y") }));
 
-  expectTypeOf<z.infer<typeof p>>().toEqualTypeOf<{ a: "x"; b: "y" }>();
+  // asserts in place: extra keys pass, and every failing key reports
+  expect(s.safeParse({ a: "x", b: "y", extra: 1 }).success).toBe(true);
+  expect(s.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
 
-  // asserts in place: the parse returns the input identity, extra keys pass
-  const ok = { a: "x", b: "y", extra: 1 };
-  expect(p.parse(ok)).toBe(ok);
-
-  // every failing key reports
-  expect(p.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
-
-  // as a schema it is the type gate and infers an object shape, so a primitive is a type error
-  for (const input of [null, undefined, 5, "abc"]) {
-    expect(p.safeParse(input).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
-  }
-
-  // as a check the base already typed the value, so the properties are asserted on whatever it produced — a string's length, as z.property() does
-  const long = z.string().check(...z.properties({ length: z.number().min(3) }));
+  // the base already typed the value, so the properties are asserted on whatever it produced — a string's length, as z.property() does
+  const long = z.string().check(z.properties({ length: z.number().min(3) }));
   expect(long.parse("abc")).toBe("abc");
   expect(long.safeParse("ab").error!.issues.map((i) => i.path)).toEqual([["length"]]);
   expect(
@@ -29,29 +19,19 @@ test("z.properties is a schema", () => {
       .error!.issues.map((i) => i.path)
   ).toEqual([["length"]]);
 
-  // an optional key may be absent
-  const opt = z.properties({ a: z.string().optional() });
-  expect(opt.safeParse({}).success).toBe(true);
-  expectTypeOf<z.infer<typeof opt>>().toEqualTypeOf<{ a?: string | undefined }>();
+  // not a schema
+  // @ts-expect-error a check has no parse of its own
+  z.properties({ a: z.string() }).parse;
 });
 
 test("z.properties discards transformed output", () => {
   // asserts and never writes back, exactly as z.property() behaves; a nested object schema rebuilds its output even without transforms, so identity cannot distinguish the two
-  const p = z.properties({ a: z.string().transform((s) => s.toUpperCase()) });
+  const s = z.any().check(z.properties({ a: z.string().transform((s) => s.toUpperCase()) }));
   const input = { a: "hi" };
-  expect(p.parse(input)).toBe(input);
+  expect(s.parse(input)).toBe(input);
   expect(input.a).toBe("hi");
 });
 
-test("z.properties narrows through intersection", () => {
-  const httpsUrl = z.instanceof(URL).and(z.properties({ protocol: z.literal("https:") }));
-  expectTypeOf<z.infer<typeof httpsUrl>>().toEqualTypeOf<URL & { protocol: "https:" }>();
-
-  const u = new URL("https://example.com");
-  expect(httpsUrl.parse(u)).toBe(u);
-  expect(httpsUrl.safeParse(new URL("http://example.com")).success).toBe(false);
-});
-
 test("z.instanceof().properties()", () => {
   const httpsUrl = z.instanceof(URL).properties({ protocol: z.literal("https:") });
   expectTypeOf<z.infer<typeof httpsUrl>>().toEqualTypeOf<URL & { protocol: "https:" }>();
@@ -65,38 +45,42 @@ test("z.instanceof().properties()", () => {
   expectTypeOf<z.infer<typeof chained>>().toEqualTypeOf<URL & { protocol: "https:" } & { port: "" }>();
   expect(chained.safeParse(u).success).toBe(true);
   expect(chained.safeParse(new URL("https://example.com:8443")).error!.issues.map((i) => i.path)).toEqual([["port"]]);
+
+  // nothing is written back, so the narrowing is over the shape's input side
+  const W = z.instanceof(URL).properties({ search: z.string().transform((s) => s.length) });
+  expectTypeOf<z.infer<typeof W>>().toEqualTypeOf<URL & { search: string }>();
+});
+
+test("z.instanceof().properties() constrains the shape to the instance type", () => {
+  const file = z.instanceof(File).properties({ name: z.string(), size: z.number().max(1024) });
+  expectTypeOf<z.infer<typeof file>>().toEqualTypeOf<File & { name: string; size: number }>();
+
+  // @ts-expect-error no such property on File
+  z.instanceof(File).properties({ nmae: z.string() });
+
+  // @ts-expect-error File["size"] is a number
+  z.instanceof(File).properties({ size: z.string() });
+
+  // methods are out of the shape, so an object literal's inherited toString can't collide with the constraint
+  // @ts-expect-error
+  z.instanceof(File).properties({ text: z.any() });
+
+  // a literal still narrows a wider property
+  const png = z.instanceof(File).properties({ type: z.literal("image/png") });
+  expectTypeOf<z.infer<typeof png>>().toEqualTypeOf<File & { type: "image/png" }>();
 });
 
 test("z.properties spreads into .check()", () => {
-  // the pre-4.6 array call sites: the schema yields itself from Symbol.iterator
+  // the 4.5 array call sites: the check yields itself from Symbol.iterator
   const p = z.properties({ a: z.literal("x") });
-  const spread = [...p];
-  expect(spread).toEqual([p]);
+  expect([...p]).toEqual([p]);
 
   const s = z.object({ a: z.string() }).check(...z.properties({ a: z.literal("x") }));
   expect(s.safeParse({ a: "x" }).success).toBe(true);
   expect(s.safeParse({ a: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"]]);
 });
 
-test("z.properties JSON Schema", () => {
-  const p = z.properties({ a: z.string(), b: z.number().optional() });
-  expect(z.toJSONSchema(p)).toEqual({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    type: "object",
-    properties: { a: { type: "string" }, b: { type: "number" } },
-    required: ["a"],
-  });
-});
-
-test("z.properties compiles", () => {
-  const p = z.properties({ a: z.literal("x"), b: z.literal("y") });
-  const compiled = z.compile(p);
-  const ok = { a: "x", b: "y", extra: 1 };
-  expect(compiled.parse(ok)).toBe(ok);
-  expect(compiled.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
-  expect(compiled.safeParse(null).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
-
-  // nested in a container
+test("z.properties compiles inside a container", () => {
   const outer = z.compile(z.object({ url: z.instanceof(URL).properties({ protocol: z.literal("https:") }) }));
   expect(outer.safeParse({ url: new URL("http://example.com") }).error!.issues.map((i) => i.path)).toEqual([
     ["url", "protocol"],
@@ -104,43 +88,28 @@ test("z.properties compiles", () => {
 });
 
 test("z.properties async", async () => {
-  const p = z.properties({ a: z.string().refine(async (s) => s.length > 1) });
+  const s = z.any().check(z.properties({ a: z.string().refine(async (s) => s.length > 1) }));
   const ok = { a: "hi" };
-  await expect(p.parseAsync(ok)).resolves.toBe(ok);
-  const bad = await p.safeParseAsync({ a: "!" });
+  await expect(s.parseAsync(ok)).resolves.toBe(ok);
+  const bad = await s.safeParseAsync({ a: "!" });
   expect(bad.error!.issues.map((i) => i.path)).toEqual([["a"]]);
 });
 
-test("z.properties infers the input side", () => {
-  // nothing is written back, so an output-typed inference would lie for every shape entry whose output differs from its input
-  const withDefault = z.properties({ a: z.string().default("x") });
-  expectTypeOf<z.infer<typeof withDefault>>().toEqualTypeOf<{ a?: string | undefined }>();
-  expect(withDefault.parse({})).toEqual({});
-
-  const withTransform = z.properties({ a: z.string().transform((s) => s.length) });
-  expectTypeOf<z.infer<typeof withTransform>>().toEqualTypeOf<{ a: string }>();
-  expect(withTransform.parse({ a: "hi" })).toEqual({ a: "hi" });
-
-  // a plain schema has the same input and output, so the documented narrowing is unchanged
-  const W = z.instanceof(URL).properties({ protocol: z.literal("https:") });
-  expectTypeOf<z.infer<typeof W>>().toEqualTypeOf<URL & { protocol: "https:" }>();
-});
-
 test("z.properties validates symbol keys", () => {
   const sym = Symbol("tag");
-  const p = z.properties({ [sym]: z.string() });
-  expect(p.safeParse({ [sym]: "ok" }).success).toBe(true);
-  expect(p.safeParse({ [sym]: 123 }).error!.issues.map((i) => i.path)).toEqual([[sym]]);
+  const s = z.any().check(z.properties({ [sym]: z.string() }));
+  expect(s.safeParse({ [sym]: "ok" }).success).toBe(true);
+  expect(s.safeParse({ [sym]: 123 }).error!.issues.map((i) => i.path)).toEqual([[sym]]);
   expect(
     z
-      .compile(p)
+      .compile(s)
       .safeParse({ [sym]: 123 })
       .error!.issues.map((i) => i.path)
   ).toEqual([[sym]]);
 });
 
 test("z.properties compiled and interpreted agree on a nullish value", () => {
-  // a base that permits null reaches the check role with one; the compiled property read must not throw where the runtime reports an issue
+  // a base that permits null reaches the check with one; the compiled property read must not throw where the runtime reports an issue
   const s = z.any().check(...z.properties({ a: z.string() }));
   const expected = [["invalid_type", []]];
   expect(s.safeParse(null).error!.issues.map((i) => [i.code, i.path])).toEqual(expected);
@@ -153,73 +122,20 @@ test("z.properties compiled and interpreted agree on a nullish value", () => {
 });
 
 test("z.properties with a custom when refuses to compile", () => {
-  // `when` is not publicly settable, since it gates a check inside the run loop and means nothing to a parsed schema. A hand-built def can still carry one, and compiling it must refuse rather than run the shape unconditionally: a union branch compiles to its own IIFE, so a wrong rejection is absorbed as a branch failure with no fallback.
-  const p = new z.core.$ZodProperties({
-    type: "properties",
-    check: "properties",
-    shape: { a: z.literal("x") },
-    when: () => false,
-  });
-  const s = z.union([p as unknown as z.ZodType, z.object({ b: z.string() })]);
+  // `when` is not publicly settable, since it gates the assertion inside the run loop. A hand-built def can still carry one, and compiling it must refuse rather than run the shape unconditionally: a union branch compiles to its own IIFE, so a wrong rejection is absorbed as a branch failure with no fallback.
+  const p = new z.core.$ZodCheckProperties({ check: "properties", shape: { a: z.literal("x") }, when: () => false });
+  const s = z.union([z.any().check(p), z.object({ b: z.string() })]);
   const input = { a: "wrong", b: "hello" };
   expect(z.compile(s).safeParse(input)).toEqual(s.safeParse(input));
 });
 
-test("z.properties parses cyclic input", () => {
-  // the input is its own output, so it registers as its own memo entry; without that a cycle re-enters forever
-  const Node: z.ZodType<{ id: string; next?: unknown }> = z.lazy(() =>
-    z.properties({ id: z.string(), next: Node.optional() })
-  );
-  const cyclic: Record<string, unknown> = { id: "a" };
-  cyclic.next = cyclic;
-  expect(Node.parse(cyclic)).toBe(cyclic);
-  expect(z.compile(Node).parse(cyclic)).toBe(cyclic);
-
-  // the cycle guard must not swallow a real failure further down
-  expect(Node.safeParse({ id: "a", next: { id: 1 } }).error!.issues.map((i) => i.path)).toEqual([["next", "id"]]);
-});
-
-test("z.properties asserts forward while encoding", () => {
-  // both sides declare the shape's input type, so encoding must still check the value against it; running the children backward would encode them and reject that type
-  const codec = z.codec(z.string(), z.number(), { decode: (s) => Number(s), encode: (n) => String(n) });
-  const p = z.properties({ a: codec, b: z.string().transform((s) => s.length) });
-  const value = { a: "1", b: "hi" };
-  expect(z.decode(p, value)).toBe(value);
-  expect(z.encode(p, value)).toBe(value);
-  expect(z.safeEncode(p, { a: 1, b: "hi" } as never).error!.issues.map((i) => i.path)).toEqual([["a"]]);
-});
-
-test("z.properties parses a cyclic callable", () => {
-  // property reads work on a function too, so the cycle guard has to recognize one as a reference
-  const Fn: z.ZodType<{ self?: unknown }> = z.lazy(() => z.properties({ self: Fn.optional() }));
-  const fn = (() => {}) as unknown as Record<string, unknown>;
-  fn.self = fn;
-  expect(Fn.parse(fn)).toBe(fn);
-});
-
 test("z.properties survives shape mutation", () => {
   // key and schema are snapshotted together; caching one and reading the other live paired a stale key with a missing schema
   const shape: Record<string, z.ZodType> = { a: z.string() };
-  const p = z.properties(shape);
-  expect(p.safeParse({ a: "x" }).success).toBe(true);
+  const s = z.any().check(z.properties(shape));
+  expect(s.safeParse({ a: "x" }).success).toBe(true);
   delete shape.a;
-  expect(p.safeParse({ a: "x" }).success).toBe(true);
+  expect(s.safeParse({ a: "x" }).success).toBe(true);
   shape.b = z.string();
-  expect(p.safeParse({ a: "x" }).success).toBe(true);
-});
-
-test("z.properties JSON Schema describes the input side", () => {
-  // the parsed value is the input, so a defaulted key that stays absent must not be required of the output either
-  const p = z.properties({ a: z.string().default("x") });
-  expect(p.parse({})).toEqual({});
-  expect(z.toJSONSchema(p, { io: "output" })).toEqual({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    type: "object",
-    properties: { a: { default: "x", type: "string" } },
-  });
-
-  // an output mode emission for a transforming child would describe a value this schema never returns
-  const t = z.properties({ a: z.string().transform((s) => s.length) });
-  expect(() => z.toJSONSchema(t, { io: "output" })).toThrow(/cannot be represented/);
-  expect(z.toJSONSchema(t, { io: "input" })).toMatchObject({ properties: { a: { type: "string" } }, required: ["a"] });
+  expect(s.safeParse({ a: "x" }).success).toBe(true);
 });

package/node_modules/zod/src/v4/classic/tests/string.test.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -12,6 +12,63 @@ const includesFromIndex2 = z.string().includes("includes", { position: 2 });
 const startsWith = z.string().startsWith("startsWith");
 const endsWith = z.string().endsWith("endsWith");
 
+test("string factory checks", async () => {
+  const schema = z.string({ checks: [z.minLength(1), z.maxLength(3)] as const });
+  const chained = z.string().min(1).max(3);
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<string>();
+  for (const value of ["", "ab", "abcd", 1, undefined]) {
+    expect(z.validate(schema, value)).toBe(z.validate(chained, value));
+    expect(schema.safeParse(value)).toEqual(chained.safeParse(value));
+  }
+  expect(z.toJSONSchema(schema)).toEqual(z.toJSONSchema(chained));
+  expect(schema.minLength).toBe(1);
+  expect(schema.maxLength).toBe(3);
+  expect(schema._zod.parent).toBeUndefined();
+  expect([...schema._zod.traits]).toEqual([...chained._zod.traits]);
+  const extended = schema.max(2);
+  expect(extended._zod.parent).toBe(schema);
+  expect(z.validate(schema, "abc")).toBe(true);
+  expect(z.validate(extended, "abc")).toBe(false);
+  const coerce = z.coerce.string({ checks: [z.minLength(2)] });
+  expect(coerce.parse(12)).toBe("12");
+  expect(z.validate(coerce, 1)).toBe(false);
+  const asyncSchema = z.string({
+    checks: [
+      z.check<string>(async (ctx) => {
+        if (ctx.value !== "ok") ctx.issues.push({ code: "custom", input: ctx.value });
+      }),
+    ],
+  });
+  expect(await asyncSchema.safeParseAsync("ok")).toEqual({ success: true, data: "ok" });
+  expect((await asyncSchema.safeParseAsync("bad")).success).toBe(false);
+  // @ts-expect-error numeric checks cannot validate strings
+  z.string({ checks: [z.gte(1)] });
+});
+
+test("factory checks snapshot caller arrays", () => {
+  for (const factory of [z.string, z.coerce.string]) {
+    for (const initial of [[], [z.minLength(1)]]) {
+      const schema = factory({ checks: initial });
+      let reads = 0;
+      const getterSchema = factory({
+        get checks() {
+          if (++reads > 1) throw new Error("checks read twice");
+          return initial;
+        },
+      });
+      expect(reads).toBe(1);
+      expect(z.validate(getterSchema, "long")).toBe(true);
+      const before = z.toJSONSchema(schema);
+      initial.push(z.minLength(10));
+      expect(schema._zod.def.checks).not.toBe(initial);
+      expect(z.validate(schema, "long")).toBe(true);
+      expect(z.validate(z.compile(schema), "long")).toBe(true);
+      expect(z.toJSONSchema(schema)).toEqual(before);
+      expect(z.validate(schema.check(z.minLength(2)), "long")).toBe(true);
+    }
+  }
+});
+
 test("length checks", () => {
   minFive.parse("12345");
   minFive.parse("123456");
@@ -1289,6 +1346,18 @@ test("hostname", () => {
   expect(() => hostname.parse("example..com")).toThrow();
 });
 
+test("currency code", () => {
+  const currency = z.currencyCode();
+  for (const code of ["USD", "EUR", "XXX", "XCG", "XAD"]) expect(currency.parse(code)).toBe(code);
+  for (const input of ["", "usd", "US", "USDX", " USD", "ANG", "BGN"])
+    expect(currency.safeParse(input).success).toBe(false);
+  expect(currency.safeParse("usd").error!.issues[0]).toMatchObject({
+    code: "invalid_format",
+    format: "currency_code",
+    message: "Invalid currency code",
+  });
+});
+
 test("hash validation", () => {
   // MD5 tests
   const md5hex = z.hash("md5");

package/node_modules/zod/src/v4/classic/tests/to-json-schema.test.ts

@@ -1,5 +1,5 @@
 import { Validator } from "@seriousme/openapi-schema-validator";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import * as z from "zod";
 // import * as zCore from "zod/v4/core";
 
@@ -3235,11 +3235,31 @@ test("basic registry", () => {
   `);
 });
 
-test("large registry converts in linear time", () => {
-  const count = 2000;
-  const convert = (withIntersection: boolean) => {
+function countMapScanWork<T>(convert: () => T): { result: T; work: number } {
+  const entries = Map.prototype.entries;
+  const values = Map.prototype.values;
+  let work = 0;
+  const entriesSpy = vi.spyOn(Map.prototype, "entries").mockImplementation(function (this: Map<unknown, unknown>) {
+    work += this.size;
+    return entries.call(this);
+  } as typeof Map.prototype.entries);
+  const valuesSpy = vi.spyOn(Map.prototype, "values").mockImplementation(function (this: Map<unknown, unknown>) {
+    work += this.size;
+    return values.call(this);
+  } as typeof Map.prototype.values);
+  try {
+    return { result: convert(), work };
+  } finally {
+    entriesSpy.mockRestore();
+    valuesSpy.mockRestore();
+  }
+}
+
+test("large registry conversion performs linear map-scan work", () => {
+  const count = 64;
+  const convert = (size: number, withIntersection: boolean) => {
     const registry = z.registry<{ id: string }>();
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < size; i++) {
       registry.add(
         z.object({ id: z.string(), name: z.string(), count: z.number(), nested: z.object({ a: z.boolean() }) }),
         { id: `Type${i}` }
@@ -3247,55 +3267,53 @@ test("large registry converts in linear time", () => {
     }
     if (withIntersection) registry.add(z.object({ a: z.string() }).and(z.object({ b: z.string() })), { id: "Inter" });
 
-    const start = performance.now();
-    const { schemas } = z.toJSONSchema(registry, { uri: (id) => `https://example.com/${id}.json` });
-    return { schemas, elapsed: performance.now() - start };
+    return countMapScanWork(() => z.toJSONSchema(registry, { uri: (id) => `https://example.com/${id}.json` }));
   };
 
-  const plain = convert(false);
-  expect(Object.keys(plain.schemas)).toHaveLength(count);
-  expect(plain.schemas.Type0).toMatchObject({
+  const plain = convert(count, false);
+  const plainDouble = convert(count * 2, false);
+  expect(Object.keys(plain.result.schemas)).toHaveLength(count);
+  expect(plain.result.schemas.Type0).toMatchObject({
     $id: "https://example.com/Type0.json",
     type: "object",
     properties: { nested: { type: "object" } },
   });
-  expect(plain.schemas[`Type${count - 1}`]!.$id).toBe(`https://example.com/Type${count - 1}.json`);
-
-  // The whole-map passes in extractDefs/finalize used to re-run once per registered schema, which made this quadratic: ~9s of CPU at this size before the passes were hoisted, ~50ms after.
-  expect(plain.elapsed).toBeLessThan(5000);
+  expect(plain.result.schemas[`Type${count - 1}`]!.$id).toBe(`https://example.com/Type${count - 1}.json`);
+  expect(plain.work).toBeGreaterThan(0);
+  expect(plainDouble.work).toBeLessThanOrEqual(plain.work * 2);
 
-  // The intersection fold walks the whole map as well, so it has to run inside the same guard. Hoisting it back out costs ~10x at this size. Comparing the two conversions rather than asserting a fixed budget keeps this independent of how fast the machine is.
-  const folded = convert(true);
-  expect(folded.schemas.Inter).toMatchObject({ type: "object", properties: { a: {}, b: {} } });
-  expect(folded.elapsed).toBeLessThan(plain.elapsed * 4 + 100);
+  const folded = convert(count, true);
+  const foldedDouble = convert(count * 2, true);
+  expect(folded.result.schemas.Inter).toMatchObject({ type: "object", properties: { a: {}, b: {} } });
+  expect(folded.work).toBeGreaterThan(0);
+  expect(foldedDouble.work).toBeLessThanOrEqual(folded.work * 2);
 });
 
-test("a registry of records with numeric keys converts in linear time", () => {
-  const count = 2000;
-  const convert = (key: (i: number) => z.core.$ZodType) => {
+test("a registry of records with numeric keys performs linear map-scan work", () => {
+  const count = 64;
+  const convert = (size: number, key: (i: number) => z.core.$ZodType) => {
     const registry = z.registry<{ id: string }>();
-    for (let i = 0; i < count; i++) {
+    for (let i = 0; i < size; i++) {
       registry.add(z.object({ m: z.record(key(i) as z.core.$ZodRecordKey, z.boolean()) }), { id: `Type${i}` });
     }
-    const start = performance.now();
-    const { schemas } = z.toJSONSchema(registry, { uri: (id) => `https://example.com/${id}.json` });
-    return { schemas, elapsed: performance.now() - start };
+    return countMapScanWork(() => z.toJSONSchema(registry, { uri: (id) => `https://example.com/${id}.json` }));
   };
 
-  const string = convert(() => z.string());
-  const numeric = convert(() => z.number());
-  expect(numeric.schemas.Type0).toMatchObject({
+  const numeric = convert(count, () => z.number());
+  const numericDouble = convert(count * 2, () => z.number());
+  expect(numeric.result.schemas.Type0).toMatchObject({
     properties: { m: { propertyNames: { type: "string", pattern: "^-?\\d+(?:\\.\\d+)?$" } } },
   });
+  expect(numeric.work).toBeGreaterThan(0);
+  expect(numericDouble.work).toBeLessThanOrEqual(numeric.work * 2);
 
-  // The rewrite has to find every carrier the flatten copied `propertyNames` onto, which means a pass over the whole seen map. Running that once per record rather than once per conversion cost ~10x at this size. A string key needs no rewrite at all, so comparing against it keeps this independent of how fast the machine is.
-  expect(numeric.elapsed).toBeLessThan(string.elapsed * 2 + 50);
-
-  // An extracted key resolves through a map built once per conversion rather than a search per reference. There is no stable timing control for that — extraction has its own $defs cost, which swamps the difference — so this only pins the shape.
-  const extracted = convert((i) => z.number().meta({ id: `Key${i}` }));
-  expect(extracted.schemas.Type0).toMatchObject({
+  const extracted = convert(count, (i) => z.number().meta({ id: `Key${i}` }));
+  const extractedDouble = convert(count * 2, (i) => z.number().meta({ id: `Key${i}` }));
+  expect(extracted.result.schemas.Type0).toMatchObject({
     properties: { m: { propertyNames: { type: "string", pattern: "^-?\\d+(?:\\.\\d+)?$" } } },
   });
+  expect(extracted.work).toBeGreaterThan(0);
+  expect(extractedDouble.work).toBeLessThanOrEqual(extracted.work * 2);
 });
 
 test("registry extracts unregistered subschemas into __shared", () => {
@@ -3849,6 +3867,31 @@ test("input JSON schema resolves requiredness past transform and catch wrappers"
   expect(required(z.object({ a: z.transform((v: unknown) => String(v)).pipe(z.string()) }))).toEqual(["a"]);
 });
 
+test("object required keys preserve shape order and direction", () => {
+  const symbol = Symbol("symbol");
+  const shape: z.ZodRawShape = {
+    10: z.string(),
+    2: z.string().optional(),
+    plain: z.string(),
+    optional: z.string().optional(),
+    defaulted: z.string().default("x"),
+    caught: z.string().catch("x"),
+    [symbol]: z.string(),
+  };
+  Object.defineProperty(shape, "__proto__", { value: z.string(), enumerable: true });
+  Object.defineProperty(shape, "hidden", { value: z.string(), enumerable: false });
+
+  const input = z.toJSONSchema(z.object(shape), { io: "input", unrepresentable: "any" });
+  const output = z.toJSONSchema(z.object(shape), { io: "output", unrepresentable: "any" });
+
+  expect(Object.keys(input.properties!)).toEqual(["2", "10", "plain", "optional", "defaulted", "caught", "__proto__"]);
+  expect(input.required).toEqual(["10", "plain", "caught", "__proto__"]);
+  expect(output.required).toEqual(["10", "plain", "defaulted", "caught", "__proto__"]);
+  expect(Object.prototype.hasOwnProperty.call(input.properties!, "__proto__")).toBe(true);
+  expect(input.properties).not.toHaveProperty("hidden");
+  expect(Object.getOwnPropertySymbols(input.properties!)).toEqual([]);
+});
+
 test("strip output-side examples from input JSON schema for codec", () => {
   const codec = z
     .codec(z.string(), z.number(), { decode: (s) => Number(s), encode: (n) => String(n) })
@@ -4679,3 +4722,12 @@ describe("intersection folding declines", () => {
     expect(allOf(schema)).toHaveLength(3);
   });
 });
+
+test("currency code", () => {
+  expect(z.toJSONSchema(z.currencyCode())).toEqual({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "string",
+    format: "currency_code",
+    pattern: z.regexes.currencyCode.source,
+  });
+});

package/node_modules/zod/src/v4/core/api.ts

@@ -58,16 +58,20 @@ export type CheckTypeParams<
 > = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
 
 // String
-export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce">;
+export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce"> & {
+  checks?: readonly checks.$ZodCheck<string>[];
+};
+
+function snapshotChecks<T extends { checks?: readonly checks.$ZodCheck<never>[] }>(def: T) {
+  if (def.checks) def.checks = [...def.checks];
+  return def as T & { checks?: NonNullable<T["checks"]>[number][] };
+}
 // @__NO_SIDE_EFFECTS__
 export function _string<T extends schemas.$ZodString>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodStringParams
 ): T {
-  return new Class({
-    type: "string",
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "string" as const, ...util.normalizeParams(params) }));
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -75,11 +79,7 @@ export function _coercedString<T extends schemas.$ZodString>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodStringParams
 ): T {
-  return new Class({
-    type: "string",
-    coerce: true,
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "string" as const, coerce: true, ...util.normalizeParams(params) }));
 }
 
 export type $ZodStringFormatParams = CheckTypeParams<
@@ -608,7 +608,9 @@ export function _isoDuration<T extends schemas.$ZodISODuration>(
 }
 
 // Number
-export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce">;
+export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce"> & {
+  checks?: readonly checks.$ZodCheck<number>[];
+};
 export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
 export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
 // @__NO_SIDE_EFFECTS__
@@ -616,11 +618,7 @@ export function _number<T extends schemas.$ZodNumber>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodNumberParams
 ): T {
-  return new Class({
-    type: "number",
-    checks: [],
-    ...util.normalizeParams(params),
-  });
+  return new Class(snapshotChecks({ type: "number" as const, checks: [], ...util.normalizeParams(params) }));
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -628,12 +626,9 @@ export function _coercedNumber<T extends schemas.$ZodNumber>(
   Class: util.SchemaClass<T>,
   params?: string | $ZodNumberParams
 ): T {
-  return new Class({
-    type: "number",
-    coerce: true,
-    checks: [],
-    ...util.normalizeParams(params),
-  });
+  return new Class(
+    snapshotChecks({ type: "number" as const, coerce: true, checks: [], ...util.normalizeParams(params) })
+  );
 }
 
 // @__NO_SIDE_EFFECTS__
@@ -1144,16 +1139,13 @@ export function _property<K extends string, T extends schemas.$ZodType>(
   });
 }
 
-// `when` is omitted: it gates a check inside the run loop, so it means nothing when this is parsed as a schema, and honoring it in one role only would diverge silently
-export type $ZodPropertiesParams = CheckTypeParams<schemas.$ZodProperties, "shape" | "when">;
+export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
 // @__NO_SIDE_EFFECTS__
 export function _properties<Shape extends schemas.$ZodShape>(
-  Class: util.SchemaClass<schemas.$ZodProperties>,
   shape: Shape,
-  params?: string | $ZodPropertiesParams
-): schemas.$ZodProperties<Shape> {
-  return new Class({
-    type: "properties",
+  params?: string | $ZodCheckPropertiesParams
+): checks.$ZodCheckProperties<Shape> {
+  return new checks.$ZodCheckProperties({
     check: "properties",
     shape,
     ...util.normalizeParams(params),