@willaimg/yatsp 4.3.6

package/src/v4/core/tests/compile-generative.test.ts

@@ -0,0 +1,445 @@
+import { expect, test } from "vitest";
+
+import * as z from "../../index.js";
+import { compile, compileFn } from "../compile.js";
+
+// Generative differential: random schemas over the compiled node types, a valid value for each, single corruptions of that value, and the assertion that the interpreter and the compiled schema agree on the verdict, the output, the issues and how often user callbacks ran. A fixture suite covers the compositions somebody wrote down; this covers the ones nobody did. Seeds are fixed, so a failure names the seed and the schema it built.
+
+function mulberry32(seed: number): () => number {
+  return () => {
+    seed = (seed + 0x6d2b79f5) | 0;
+    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+interface Gen {
+  schema: z.YatspType;
+  desc: string;
+  valid: () => unknown;
+  // one corruption of a valid value; not always rejected (a loose object absorbs an extra key), and both sides must agree either way
+  corrupt: (v: unknown) => unknown;
+  // this node itself has no fast emitter and compiles through the runtime
+  island: boolean;
+}
+
+interface Ctx {
+  rand: () => number;
+  // runs per generated callback, so the two-run bound holds for each one rather than for the sum
+  calls: Map<number, number>;
+  nextCallback: number;
+}
+
+function count(c: Ctx, id: number): void {
+  c.calls.set(id, (c.calls.get(id) ?? 0) + 1);
+}
+
+const pick = <T>(c: Ctx, xs: readonly T[]): T => xs[Math.floor(c.rand() * xs.length)]!;
+const int = (c: Ctx, lo: number, hi: number): number => lo + Math.floor(c.rand() * (hi - lo + 1));
+const JUNK = [42, "x", null, undefined, true, [], {}, -0, Number.NaN] as const;
+
+function leaf(c: Ctx): Gen {
+  switch (int(c, 0, 7)) {
+    case 0: {
+      const min = int(c, 0, 3);
+      return {
+        schema: z.string().min(min),
+        desc: `string.min(${min})`,
+        valid: () => "x".repeat(min + int(c, 0, 2)),
+        corrupt: () => (c.rand() < 0.5 ? 42 : "x".repeat(Math.max(0, min - 1))),
+        island: false,
+      };
+    }
+    case 1:
+      return {
+        schema: z.email(),
+        desc: "email",
+        valid: () => "a@b.co",
+        corrupt: () => (c.rand() < 0.5 ? "nope" : 1),
+        island: false,
+      };
+    case 2: {
+      const lo = int(c, -5, 0);
+      const hi = int(c, 1, 5);
+      return {
+        schema: z.number().int().min(lo).max(hi),
+        desc: `int[${lo},${hi}]`,
+        valid: () => int(c, lo, hi),
+        corrupt: () => pick(c, [hi + 1, lo - 1, 1.5, "1"]),
+        island: false,
+      };
+    }
+    case 3:
+      return {
+        schema: z.boolean(),
+        desc: "boolean",
+        valid: () => c.rand() < 0.5,
+        corrupt: () => pick(c, ["true", 0, null]),
+        island: false,
+      };
+    case 4: {
+      const lit = pick(c, ["a", 1, true] as const);
+      return {
+        schema: z.literal(lit),
+        desc: `literal(${JSON.stringify(lit)})`,
+        valid: () => lit,
+        corrupt: () => pick(c, ["b", 2, false]),
+        island: false,
+      };
+    }
+    case 5:
+      return {
+        schema: z.enum(["a", "b", "c"]),
+        desc: "enum",
+        valid: () => pick(c, ["a", "b", "c"]),
+        corrupt: () => pick(c, ["d", 2, null]),
+        island: false,
+      };
+    case 6: {
+      const id = c.nextCallback++;
+      return {
+        schema: z.number().superRefine((v, ctx) => {
+          count(c, id);
+          if (v < 0) ctx.addIssue({ code: "custom", message: "negative" });
+        }),
+        desc: "number.superRefine",
+        valid: () => int(c, 0, 9),
+        corrupt: () => pick(c, [-1, "x"]),
+        island: false,
+      };
+    }
+    default: {
+      const id = c.nextCallback++;
+      return {
+        schema: z.string().transform((s) => {
+          count(c, id);
+          return s.length;
+        }),
+        desc: "string.transform",
+        valid: () => "y".repeat(int(c, 0, 3)),
+        corrupt: () => 42,
+        island: false,
+      };
+    }
+  }
+}
+
+function wrap(c: Ctx, inner: Gen): Gen {
+  switch (int(c, 0, 4)) {
+    case 0:
+      return {
+        ...inner,
+        schema: inner.schema.optional(),
+        desc: `${inner.desc}.optional`,
+        valid: () => (c.rand() < 0.3 ? undefined : inner.valid()),
+        island: false,
+      };
+    case 1:
+      return {
+        ...inner,
+        schema: inner.schema.nullable(),
+        desc: `${inner.desc}.nullable`,
+        valid: () => (c.rand() < 0.3 ? null : inner.valid()),
+        island: false,
+      };
+    case 2: {
+      const dflt = inner.valid();
+      return {
+        ...inner,
+        schema: inner.schema.default(dflt as never),
+        desc: `${inner.desc}.default`,
+        valid: () => (c.rand() < 0.3 ? undefined : inner.valid()),
+        island: false,
+      };
+    }
+    case 3:
+      return { ...inner, schema: inner.schema.readonly(), desc: `${inner.desc}.readonly`, island: false };
+    default:
+      return {
+        ...inner,
+        schema: inner.schema.optional().nonoptional(),
+        desc: `${inner.desc}.optional.nonoptional`,
+        corrupt: (v) => (c.rand() < 0.5 ? undefined : inner.corrupt(v)),
+        island: false,
+      };
+  }
+}
+
+function container(c: Ctx, depth: number): Gen {
+  const child = () => gen(c, depth - 1);
+  switch (int(c, 0, 8)) {
+    case 0:
+    case 1: {
+      const n = int(c, 1, 4);
+      const entries = Array.from({ length: n }, (_, i) => [`k${i}`, child(), c.rand() < 0.3] as const);
+      const shape = Object.fromEntries(entries.map(([k, g, opt]) => [k, opt ? g.schema.optional() : g.schema]));
+      const mode = pick(c, ["plain", "strict", "loose", "catchall"] as const);
+      const schema =
+        mode === "strict"
+          ? z.strictObject(shape)
+          : mode === "loose"
+            ? z.looseObject(shape)
+            : mode === "catchall"
+              ? z.object(shape).catchall(z.number())
+              : z.object(shape);
+      const valid = () => {
+        const o: Record<string, unknown> = {};
+        for (const [k, g, opt] of entries) if (!opt || c.rand() < 0.6) o[k] = g.valid();
+        if (mode === "catchall" && c.rand() < 0.5) o.extra = 1;
+        return o;
+      };
+      return {
+        schema,
+        desc: `${mode}{${entries.map(([k, g, opt]) => `${k}${opt ? "?" : ""}:${g.desc}`).join(",")}}`,
+        valid,
+        corrupt: (v) => {
+          if (typeof v !== "object" || v === null) return v;
+          const o = { ...(v as Record<string, unknown>) };
+          const [k, g, opt] = pick(c, entries);
+          switch (int(c, 0, 3)) {
+            case 0:
+              o[k] = g.corrupt(k in o ? o[k] : g.valid());
+              break;
+            case 1:
+              if (opt) o[k] = g.corrupt(g.valid());
+              else delete o[k];
+              break;
+            case 2:
+              o.extra = "e";
+              break;
+            default:
+              return 42;
+          }
+          return o;
+        },
+        island: false,
+      };
+    }
+    case 2: {
+      const g = child();
+      const min = int(c, 0, 2);
+      return {
+        schema: z.array(g.schema).min(min),
+        desc: `array(${g.desc}).min(${min})`,
+        valid: () => Array.from({ length: min + int(c, 0, 2) }, () => g.valid()),
+        corrupt: (v) => {
+          if (!Array.isArray(v)) return v;
+          const a = [...v];
+          if (a.length && c.rand() < 0.6) a[int(c, 0, a.length - 1)] = g.corrupt(a[0]);
+          else if (min > 0) a.length = min - 1;
+          else return 42;
+          return a;
+        },
+        island: false,
+      };
+    }
+    case 3: {
+      const items = Array.from({ length: int(c, 1, 3) }, child);
+      const rest = c.rand() < 0.4 ? child() : null;
+      const schema = rest
+        ? z.tuple(items.map((g) => g.schema) as [z.YatspType, ...z.YatspType[]], rest.schema)
+        : z.tuple(items.map((g) => g.schema) as [z.YatspType, ...z.YatspType[]]);
+      return {
+        schema,
+        desc: `tuple(${items.map((g) => g.desc).join(",")}${rest ? `,...${rest.desc}` : ""})`,
+        valid: () => [
+          ...items.map((g) => g.valid()),
+          ...(rest ? Array.from({ length: int(c, 0, 2) }, () => rest.valid()) : []),
+        ],
+        corrupt: (v) => {
+          if (!Array.isArray(v)) return v;
+          const a = [...v];
+          const i = int(c, 0, items.length - 1);
+          if (c.rand() < 0.6) a[i] = items[i]!.corrupt(a[i]);
+          else if (c.rand() < 0.5) a.push("extra");
+          else a.length = i;
+          return a;
+        },
+        island: false,
+      };
+    }
+    case 4: {
+      const g = child();
+      const enumKeys = c.rand() < 0.4;
+      const schema = enumKeys ? z.record(z.enum(["a", "b"]), g.schema) : z.record(z.string(), g.schema);
+      return {
+        schema,
+        desc: `record(${enumKeys ? "enum" : "string"},${g.desc})`,
+        valid: () =>
+          enumKeys
+            ? { a: g.valid(), b: g.valid() }
+            : Object.fromEntries(Array.from({ length: int(c, 0, 3) }, (_, i) => [`r${i}`, g.valid()])),
+        corrupt: (v) => {
+          if (typeof v !== "object" || v === null) return v;
+          const o = { ...(v as Record<string, unknown>) };
+          const keys = Object.keys(o);
+          if (keys.length && c.rand() < 0.6) o[pick(c, keys)] = g.corrupt(o[keys[0]!]);
+          else if (enumKeys) o.z = g.valid();
+          else return 42;
+          return o;
+        },
+        island: false,
+      };
+    }
+    case 5: {
+      const options = Array.from({ length: int(c, 2, 3) }, child);
+      return {
+        schema: z.union(options.map((g) => g.schema) as [z.YatspType, z.YatspType, ...z.YatspType[]]),
+        desc: `union(${options.map((g) => g.desc).join("|")})`,
+        valid: () => pick(c, options).valid(),
+        corrupt: (v) => pick(c, options).corrupt(v),
+        island: false,
+      };
+    }
+    case 6: {
+      const branches = Array.from({ length: int(c, 2, 3) }, (_, i) => [i, child()] as const);
+      return {
+        schema: z.discriminatedUnion(
+          "t",
+          branches.map(([i, g]) => z.object({ t: z.literal(`b${i}`), v: g.schema })) as [
+            z.YatspObject<{ t: z.YatspLiteral<string>; v: z.YatspType }>,
+            ...z.YatspObject<{ t: z.YatspLiteral<string>; v: z.YatspType }>[],
+          ]
+        ),
+        desc: `dunion(${branches.map(([, g]) => g.desc).join("|")})`,
+        valid: () => {
+          const [i, g] = pick(c, branches);
+          return { t: `b${i}`, v: g.valid() };
+        },
+        corrupt: (v) => {
+          if (typeof v !== "object" || v === null) return v;
+          const o = { ...(v as { t: string; v: unknown }) };
+          const branch = branches.find(([i]) => `b${i}` === o.t);
+          if (branch && c.rand() < 0.6) o.v = branch[1].corrupt(o.v);
+          else o.t = "nope";
+          return o;
+        },
+        island: false,
+      };
+    }
+    case 7: {
+      const min = int(c, 1, 3);
+      return {
+        schema: z.string().pipe(z.string().min(min)),
+        desc: `string.pipe(min(${min}))`,
+        valid: () => "p".repeat(min + int(c, 0, 1)),
+        corrupt: () => (c.rand() < 0.5 ? "p".repeat(min - 1) : 7),
+        island: false,
+      };
+    }
+    default: {
+      // map and set: the compiled result still has to agree
+      const g = child();
+      if (c.rand() < 0.5) {
+        return {
+          schema: z.map(z.string(), g.schema),
+          desc: `map(string,${g.desc})`,
+          valid: () => new Map(Array.from({ length: int(c, 0, 2) }, (_, i) => [`m${i}`, g.valid()])),
+          corrupt: (v) => {
+            if (!(v instanceof Map)) return v;
+            const m = new Map(v);
+            if (m.size && c.rand() < 0.7) m.set("m0", g.corrupt(m.get("m0")));
+            else return [];
+            return m;
+          },
+          island: true,
+        };
+      }
+      return {
+        schema: z.set(g.schema),
+        desc: `set(${g.desc})`,
+        valid: () => new Set(Array.from({ length: int(c, 0, 2) }, () => g.valid())),
+        corrupt: (v) => {
+          if (!(v instanceof Set)) return v;
+          const s = new Set(v);
+          if (c.rand() < 0.7) s.add(g.corrupt(g.valid()));
+          else return {};
+          return s;
+        },
+        island: true,
+      };
+    }
+  }
+}
+
+function gen(c: Ctx, depth: number): Gen {
+  if (depth === 0) return leaf(c);
+  const r = c.rand();
+  if (r < 0.25) return leaf(c);
+  if (r < 0.4) return wrap(c, gen(c, depth - 1));
+  return container(c, depth);
+}
+
+function attempt<T>(fn: () => T): { value?: T; threw?: string } {
+  try {
+    return { value: fn() };
+  } catch (err) {
+    return { threw: (err as Error)?.constructor?.name || "Error" };
+  }
+}
+
+function describe(value: unknown): string {
+  return JSON.stringify(value, (_k, v) =>
+    v instanceof Map ? { $map: [...v] } : v instanceof Set ? { $set: [...v] } : v === undefined ? "$undefined" : v
+  );
+}
+
+// own-key order and undefined-valued-vs-absent keys, which toStrictEqual does not see
+function shape(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(shape);
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return Reflect.ownKeys(value).map((k) => [k, shape((value as Record<PropertyKey, unknown>)[k])]);
+  }
+  return value;
+}
+
+const SEEDS = 400;
+
+test("random schemas parse identically through the interpreter and the compiler", () => {
+  // every failing seed is collected, so one run names all of them
+  const failures: string[] = [];
+  for (let seed = 1; seed <= SEEDS; seed++) {
+    try {
+      checkSeed(seed);
+    } catch (err) {
+      failures.push((err as Error).message.split("\n")[0]!);
+    }
+  }
+  expect(failures).toEqual([]);
+});
+
+function checkSeed(seed: number): void {
+  {
+    const c: Ctx = { rand: mulberry32(seed), calls: new Map(), nextCallback: 0 };
+    const g = gen(c, 3);
+    const compiled = compile(g.schema);
+    const inputs = [g.valid(), g.corrupt(g.valid()), g.corrupt(g.corrupt(g.valid())), pick(c, JUNK)];
+    for (const input of inputs) {
+      const label = `seed ${seed} ${g.desc} input ${describe(input)}`;
+      c.calls.clear();
+      const a = attempt(() => g.schema.safeParse(input));
+      const runtimeCalls = new Map(c.calls);
+      c.calls.clear();
+      const b = attempt(() => compiled.safeParse(input));
+      const compiledCalls = new Map(c.calls);
+      expect(b.threw, `${label}: throw`).toBe(a.threw);
+      if (a.threw) continue;
+      expect(b.value!.success, `${label}: verdict`).toBe(a.value!.success);
+      if (a.value!.success) {
+        expect(b.value!.data, `${label}: data`).toStrictEqual(a.value!.data);
+        expect(shape(b.value!.data), `${label}: key order`).toEqual(shape(a.value!.data));
+      } else {
+        expect(b.value!.error!.issues, `${label}: issues`).toEqual(a.value!.error!.issues);
+      }
+      // every callback the interpreter reaches, the compiled schema reaches too; the fast pass runs it at most once and the runtime re-parse at most once more
+      for (const id of new Set([...compiledCalls.keys(), ...runtimeCalls.keys()])) {
+        const n = compiledCalls.get(id) ?? 0;
+        const r = runtimeCalls.get(id) ?? 0;
+        expect(n, `${label}: callback ${id} ran ${n} vs ${r}`).toBeGreaterThanOrEqual(r);
+        expect(n, `${label}: callback ${id} ran ${n} vs ${r}`).toBeLessThanOrEqual(2 * r);
+      }
+    }
+    expect(() => compileFn(g.schema), `${g.desc}: compile refused`).not.toThrow();
+  }
+}

package/src/v4/core/tests/compile-global.test.ts

@@ -0,0 +1,89 @@
+// Tests the `yatsp/compile` subpath module — the user-facing API for enabling global AOT compilation. Importing this file (or running it under compile-mode where the setup file already imported `yatsp/compile`) installs the post-processor for the duration of this vitest worker. Vitest's `isolate: true` puts each test file in its own worker, so the install doesn't leak to other files.
+
+import { expect, test } from "vitest";
+import "yatsp/compile";
+import * as z from "yatsp/v4";
+import * as core from "yatsp/v4/core";
+
+test("yatsp/compile sets globalConfig.postProcessor", () => {
+  expect(typeof core.globalConfig.postProcessor).toBe("function");
+});
+
+test("z.compile is exported from the public namespace", () => {
+  expect(typeof z.compile).toBe("function");
+  const schema = z.compile(z.object({ name: z.string() }));
+  expect(schema.parse({ name: "ok" })).toEqual({ name: "ok" });
+});
+
+test("schemas constructed after import are compiled on first parse", () => {
+  const schema = z.object({ name: z.string(), age: z.number() });
+
+  // First parse: shim fires, compiles, replaces self.
+  const r1 = schema.safeParse({ name: "ok", age: 1 });
+  expect(r1.success).toBe(true);
+
+  // Second parse: directly through compiled wrapper.
+  const r2 = schema.safeParse({ name: "ok", age: 2 });
+  expect(r2.success).toBe(true);
+
+  const bad = schema.safeParse({ name: 1, age: "x" });
+  expect(bad.success).toBe(false);
+});
+
+test("user callbacks run at most twice on invalid input", () => {
+  let refines = 0;
+  const schema = z.object({
+    a: z.string().refine((v) => {
+      refines++;
+      return v.length > 1;
+    }),
+  });
+  schema.safeParse({ a: "ok" }); // trigger lazy compile
+
+  refines = 0;
+  expect(schema.safeParse({ a: "x" }).success).toBe(false);
+  expect(refines).toBe(2);
+
+  refines = 0;
+  expect(() => schema.parse({ a: "x" })).toThrow();
+  expect(refines).toBe(2);
+
+  // Explicit z.compile of a shim-managed schema keeps the same contract.
+  const compiled = z.compile(schema);
+  refines = 0;
+  expect(compiled.safeParse({ a: "x" }).success).toBe(false);
+  expect(refines).toBe(2);
+});
+
+test("global mode respects the jitless config", () => {
+  core.config({ jitless: true });
+  try {
+    const schema = z.object({ a: z.string() });
+    expect(schema.safeParse({ a: "x" }).success).toBe(true);
+    // The shim restored the runtime parser instead of compiling: a compiled wrapper carries __originalRun, the bare runtime does not.
+    expect((schema._yatsp.run as { __originalRun?: unknown }).__originalRun).toBeUndefined();
+  } finally {
+    core.config({ jitless: undefined });
+  }
+});
+
+test("schemas with unsupported features fall back without crashing", () => {
+  const schema = z.string().refine(async () => true);
+  // First call attempts compile, falls back. Subsequent calls use runtime. Sync parse of an async-refined schema is its own runtime concern; we only care that the post-processor doesn't crash with a compile error.
+  expect(() => schema.safeParse("ok")).not.toThrow(/YatspCompile/);
+});
+
+test("global mode installs the validator validate reads", () => {
+  const schema = z.looseObject({ name: z.string() });
+  schema.parse({ name: "ok", extra: 1 }); // shim fires and compiles
+
+  // Without this the shim leaves no validator behind, validate misses its fast path and answers from the runtime parser instead. Correct, so nothing else in the suite notices, and several times slower.
+  const bag = schema._yatsp.bag as { validator?: (input: unknown) => unknown };
+  expect(typeof bag.validator).toBe("function");
+
+  // a verdict rather than a rebuilt object, so this is the assert-mode codegen and not the parser
+  expect(bag.validator!({ name: "ok", extra: 1 })).toBe(true);
+
+  expect(z.validate(schema, { name: "ok", extra: 1 })).toBe(true);
+  expect(z.validate(schema, { name: 1 })).toBe(false);
+});

package/src/v4/core/tests/compile-off-by-default.test.ts

@@ -0,0 +1,26 @@
+import { expect, test } from "vitest";
+
+import * as z from "../../index.js";
+import * as core from "../index.js";
+
+// Global compilation is opt-in through `import "yatsp/compile"`, and that opt-in mutates `globalThis.__yatsp_globalConfig` — process-global state, not module state. Two things therefore have to hold, and neither is evident from reading the module: importing yatsp must not install the post-processor, and the compile-mode vitest project must not leak its setup file into the default one. Both projects run this file and each asserts the state it is supposed to be in, so a leak in either direction fails here instead of silently turning the default suite into a second compiled run (or the compiled suite into a second uncompiled one).
+const compileMode = (globalThis as any).__yatspCompileStats !== undefined;
+
+test("global compilation is installed only under compile mode", () => {
+  if (compileMode) {
+    expect(core.globalConfig.postProcessor).toBeTypeOf("function");
+  } else {
+    expect(core.globalConfig.postProcessor).toBeUndefined();
+  }
+});
+
+test("a freshly constructed schema is compiled only under compile mode", () => {
+  const schema = z.object({ a: z.string() });
+  // The global shim replaces `_yatsp.run` at construction time and tags itself with `__originalRun` so a later compile can unwrap past it. An untagged `run` is proof the post-processor never touched this schema.
+  const tagged = (schema._yatsp.run as { __originalRun?: unknown }).__originalRun !== undefined;
+  expect(tagged).toBe(compileMode);
+
+  // Either way the schema has to parse identically.
+  expect(schema.parse({ a: "x" })).toEqual({ a: "x" });
+  expect(schema.safeParse({ a: 1 }).success).toBe(false);
+});

package/src/v4/core/tests/compile-stats.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest";
+import * as z from "../../index.js";
+
+// Verifies that the compile-mode setup file is wired up correctly. Vitest's `isolate: true` resets module state per test file, so the counter only sees this file's compile attempts. We construct + parse a few schemas here to produce signal, then assert the post-processor saw them.
+//
+// When run under the default project (without the setup file), the counter is absent and the test self-skips.
+
+interface CompileStats {
+  attempts: number;
+  successes: number;
+  fallbacks: number;
+}
+
+test("compile-mode post-processor is installed and compiles supported schemas", () => {
+  const stats = (globalThis as any).__yatspCompileStats as CompileStats | undefined;
+  if (!stats) return; // Default project — compile mode disabled.
+
+  const before = { ...stats };
+
+  // Trigger compile via a handful of supported shapes
+  const cases: Array<[z.YatspType, unknown]> = [
+    [z.string(), "hi"],
+    [z.number(), 1],
+    [z.object({ name: z.string() }), { name: "ok" }],
+    [z.array(z.number()), [1, 2, 3]],
+    [z.union([z.string(), z.number()]), "x"],
+  ];
+  for (const [schema, input] of cases) {
+    schema.safeParse(input);
+  }
+
+  expect(stats.attempts - before.attempts).toBeGreaterThanOrEqual(cases.length);
+  expect(stats.successes - before.successes).toBeGreaterThanOrEqual(cases.length);
+});