@openclaw/feishu 2026.9.4 → 2026.9.5

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

@@ -0,0 +1,89 @@
+// Tests the `zod/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 `zod/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 "zod/compile";
+import * as z from "zod/v4";
+import * as core from "zod/v4/core";
+
+test("zod/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._zod.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(/ZodCompile/);
+});
+
+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._zod.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/node_modules/zod/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 "zod/compile"`, and that opt-in mutates `globalThis.__zod_globalConfig` — process-global state, not module state. Two things therefore have to hold, and neither is evident from reading the module: importing zod 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).__zodCompileStats !== 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 `_zod.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._zod.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/node_modules/zod/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).__zodCompileStats 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.ZodType, 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);
+});