@openclaw/slack 2026.9.5 → 2026.9.7

package/node_modules/zod/src/v4/core/tests/cached.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from "vitest";
+
+import { util } from "zod/v4/core";
+
+test("cached defers the getter until the first read", () => {
+  let runs = 0;
+  const box = util.cached(() => ++runs);
+  expect(runs).toBe(0);
+  expect(box.value).toBe(1);
+  expect(box.value).toBe(1);
+  expect(runs).toBe(1);
+});
+
+test("cached memoizes an undefined result", () => {
+  let runs = 0;
+  const box = util.cached(() => {
+    runs++;
+    return undefined;
+  });
+  expect(box.value).toBeUndefined();
+  expect(box.value).toBeUndefined();
+  expect(runs).toBe(1);
+});
+
+test("cached retries after the getter throws", () => {
+  let attempts = 0;
+  const box = util.cached(() => {
+    if (++attempts < 2) throw new Error("boom");
+    return "recovered";
+  });
+  expect(() => box.value).toThrow("boom");
+  expect(box.value).toBe("recovered");
+  expect(attempts).toBe(2);
+});
+
+test("cached rejects assignment to value", () => {
+  const box = util.cached(() => 1);
+  expect(() => {
+    (box as { value: number }).value = 2;
+  }).toThrow(TypeError);
+});
+
+// the getter is inherited, so a box carries only its two state slots and stays out of dictionary mode
+test("cached keeps value on the prototype", () => {
+  const box = util.cached(() => 1);
+  expect(Object.getOwnPropertyDescriptor(box, "value")).toBeUndefined();
+  expect("value" in box).toBe(true);
+  expect(box.value).toBe(1);
+});
+
+test("allowsEval reads through the same box", () => {
+  expect(util.allowsEval.value).toBe(true);
+  expect(util.allowsEval.value).toBe(true);
+});

package/node_modules/zod/src/v4/core/tests/compile-differential.test.ts

@@ -677,6 +677,41 @@ test("url options match the runtime across the whole option matrix", () => {
   for (const schema of schemas) differential(schema, inputs);
 });
 
+test("assert-only URL generation skips unused output without skipping chained transforms", () => {
+  const sanitized = "https://example.com";
+  const withNewline = "https://exa\nmple.com";
+  differential(z.url().length(sanitized.length), [sanitized, withNewline, "https://example.com/long"]);
+  differential(z.string().url().length(sanitized.length), [sanitized, withNewline, "https://example.com/long"]);
+
+  const URLStatic = URL as typeof URL & { parse: (input: string) => URL | null };
+  const descriptor = Object.getOwnPropertyDescriptor(URLStatic, "parse")!;
+  const marker = new Error("href read");
+  Object.defineProperty(URLStatic, "parse", {
+    configurable: true,
+    value: () =>
+      Object.create(URL.prototype, {
+        href: {
+          get() {
+            throw marker;
+          },
+        },
+      }) as URL,
+  });
+  try {
+    const schema = z.url({ normalize: true });
+    const parser = compileFn(schema);
+    const validator = compileFn(schema, { assertOnly: true });
+    expect(validator("https://example.com")).toBe(true);
+    expect(z.validate(compile(z.url({ normalize: true })), "https://example.com")).toBe(true);
+    expect(z.validate(compile(z.object({ url: z.url({ normalize: true }) })), { url: "https://example.com" })).toBe(
+      true
+    );
+    expect(() => parser("https://example.com")).toThrow(marker);
+  } finally {
+    Object.defineProperty(URLStatic, "parse", descriptor);
+  }
+});
+
 test("empty strict object compiles", () => {
   // With no keys the unknown-key condition is empty, and `if () return INVALID;` is a syntax error the single top-level `new Function` rejects — too late for compileChild to island, so the whole tree lost its fast path.
   differential(z.strictObject({}), [{}, { a: 1 }, Object.create({ inherited: 1 })]);

package/node_modules/zod/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.ZodType;
+  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.ZodType, ...z.ZodType[]], rest.schema)
+        : z.tuple(items.map((g) => g.schema) as [z.ZodType, ...z.ZodType[]]);
+      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.ZodType, z.ZodType, ...z.ZodType[]]),
+        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.ZodObject<{ t: z.ZodLiteral<string>; v: z.ZodType }>,
+            ...z.ZodObject<{ t: z.ZodLiteral<string>; v: z.ZodType }>[],
+          ]
+        ),
+        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();
+  }
+}