@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -57,3 +57,30 @@ test("The callback's return value becomes the apply's return value.", () => {
   expect(result).toBe(symbol);
   expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
 });
+
+test("apply forwards extra args to the callback", () => {
+  const withDefault = <TSchema extends z.ZodType>(schema: TSchema, defaultValue: z.output<TSchema>) => {
+    return schema.nullish().transform((x) => x ?? defaultValue);
+  };
+
+  const schema = z.string().apply(withDefault, "default-id");
+
+  expect(schema.parse(undefined)).toBe("default-id");
+  expect(schema.parse(null)).toBe("default-id");
+  expect(schema.parse("value")).toBe("value");
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string>();
+});
+
+test("apply type-checks the extra args", () => {
+  const withMin = (schema: z.ZodString, n: number) => schema.min(n);
+
+  expect(z.string().apply(withMin, 3).parse("abcd")).toBe("abcd");
+  expectTypeOf(z.number().apply<z.ZodNumber>((schema) => schema.min(0))).toEqualTypeOf<z.ZodNumber>();
+
+  // @ts-expect-error wrong arg type
+  z.string().apply(withMin, "3");
+  // @ts-expect-error missing arg
+  z.string().apply(withMin);
+  // @ts-expect-error extra arg for a single-parameter callback
+  z.string().apply((schema: z.ZodString) => schema, 3);
+});

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

@@ -51,7 +51,7 @@ test("array length", () => {
         "code": "too_small",
         "exact": true,
         "inclusive": true,
-        "message": "Too small: expected array to have >=2 items",
+        "message": "Too small: expected array to have exactly 2 items",
         "minimum": 2,
         "origin": "array",
         "path": [],
@@ -68,7 +68,7 @@ test("array length", () => {
         "exact": true,
         "inclusive": true,
         "maximum": 2,
-        "message": "Too big: expected array to have <=2 items",
+        "message": "Too big: expected array to have exactly 2 items",
         "origin": "array",
         "path": [],
       },

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

@@ -1,6 +1,7 @@
 import { expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
+import * as core from "zod/v4/core";
 
 test("assignability", () => {
   // $ZodString
@@ -162,11 +163,196 @@ test("assignability", () => {
   z.file() satisfies z.ZodFile;
 });
 
+test("toZod", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.string().url().nullable(),
+  });
+  const Company = z.toZod<Company>()(CompanySchema);
+
+  Company.shape.id.min(1);
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = core.toZod<Company>()(CompanySchema);
+  expectTypeOf<core.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  type Complex = {
+    kind: "company";
+    nested: {
+      founded: Date;
+      tags: string[];
+    };
+    scores: Record<"a" | "b", number>;
+    tuple: [string, number];
+    status: "active" | "inactive";
+  };
+
+  const Complex = z.toZod<Complex>()(
+    z.object({
+      kind: z.literal("company"),
+      nested: z.object({
+        founded: z.date(),
+        tags: z.array(z.string()),
+      }),
+      scores: z.record(z.enum(["a", "b"]), z.number()),
+      tuple: z.tuple([z.string(), z.number()]),
+      status: z.union([z.literal("active"), z.literal("inactive")]),
+    })
+  );
+  expectTypeOf<z.output<typeof Complex>>().toEqualTypeOf<Complex>();
+
+  type Items = {
+    items: { value: string }[];
+  };
+
+  const Items = z.toZod<Items>()(
+    z.object({
+      items: z.array(z.object({ value: z.string() })),
+    })
+  );
+  expectTypeOf<z.output<typeof Items>>().toEqualTypeOf<Items>();
+
+  type ReadonlyItem = Readonly<{
+    id: string;
+  }>;
+
+  const ReadonlyItem = z.toZod<ReadonlyItem>()(z.object({ id: z.string() }).readonly());
+  expectTypeOf<z.output<typeof ReadonlyItem>>().toEqualTypeOf<ReadonlyItem>();
+
+  const Transformed = z.toZod<{ count: number }>()(
+    z.object({
+      count: z.string().transform((value) => value.length),
+    })
+  );
+  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
+  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
+
+  // An enum target matches z.enum(...) even though the enum reference is not identical to the union of its members (#6524)
+  enum SkillLevel {
+    Noob = "noob",
+    Pro = "pro",
+  }
+  enum Rank {
+    First = 1,
+    Second = 2,
+  }
+
+  z.toZod<SkillLevel>()(z.enum(SkillLevel));
+  const Enums = z.toZod<{
+    skill: SkillLevel;
+    members: SkillLevel.Noob | SkillLevel.Pro;
+    rank: Rank;
+    maybe: SkillLevel | null;
+    list: SkillLevel[];
+    nested: { skill: SkillLevel };
+  }>()(
+    z.object({
+      skill: z.enum(SkillLevel),
+      members: z.enum(SkillLevel),
+      rank: z.enum(Rank),
+      maybe: z.enum(SkillLevel).nullable(),
+      list: z.array(z.enum(SkillLevel)),
+      nested: z.object({ skill: z.enum(SkillLevel) }),
+    })
+  );
+  expectTypeOf<z.output<typeof Enums>["skill"]>().toEqualTypeOf<SkillLevel>();
+
+  // @ts-expect-error a member subset is not the enum
+  z.toZod<{ skill: SkillLevel }>()(z.object({ skill: z.literal(SkillLevel.Noob) }));
+
+  // @ts-expect-error plain literals do not match a nominal enum target
+  z.toZod<{ skill: SkillLevel }>()(z.object({ skill: z.enum(["noob", "pro"]) }));
+
+  // @ts-expect-error an enum schema does not match a plain literal-union target
+  z.toZod<{ skill: "noob" | "pro" }>()(z.object({ skill: z.enum(SkillLevel) }));
+
+  // @ts-expect-error plain numeric literals do not match a numeric enum target either
+  z.toZod<{ rank: Rank }>()(z.object({ rank: z.union([z.literal(1), z.literal(2)]) }));
+
+  z.toZod<Company>()(
+    // @ts-expect-error missing optional keys still fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error extra keys fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      webAddress: z.string().url().nullable(),
+      extra: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.string().url().nullable(),
+    })
+  );
+
+  z.toZod<ReadonlyItem>()(
+    // @ts-expect-error readonly output is required
+    z.object({
+      id: z.string(),
+    })
+  );
+
+  // @ts-expect-error any is only an exact match for any
+  z.toZod<string>()(z.any());
+
+  // @ts-expect-error toZod checks output, not input
+  z.toZod<string>()(z.string().transform((value) => value.length));
+
+  // Exact equality is deliberately the only mode. A bidirectional-assignability mode would accept both of the two cases above — `any` is assignable in both directions by construction, and `readonly` is not part of assignability — so it would silently drop the guarantees the rest of this test pins.
+
+  // An intersection and the flat object with the same keys are interchangeable as targets, since the normalizer flattens both.
+  type Intersected = { a: number } & { b: string };
+  const viaAnd = z.object({ a: z.number() }).and(z.object({ b: z.string() }));
+  const viaExtend = z.object({ a: z.number() }).safeExtend({ b: z.string() });
+
+  z.toZod<Intersected>()(viaAnd);
+  z.toZod<Intersected>()(viaExtend);
+  z.toZod<{ a: number; b: string }>()(viaAnd);
+  z.toZod<{ a: number; b: string }>()(viaExtend);
+
+  // @ts-expect-error a missing key is still a missing key
+  z.toZod<Intersected>()(z.object({ a: z.number() }));
+
+  // `keyof` a function is `never`, so the normalizer must not walk into one — mapping it would erase the signature and make every callable compare equal
+  z.toZod<() => string>()(z.custom<() => string>());
+
+  // @ts-expect-error an incompatible callable output is still rejected
+  z.toZod<() => string>()(z.custom<() => number>());
+
+  // @ts-expect-error and so is an incompatible function-valued property
+  z.toZod<{ cb: (x: number) => void }>()(z.object({ cb: z.custom<(x: string) => void>() }));
+
+  // @ts-expect-error a method-bearing generic keeps its type arguments
+  z.toZod<{ m: Map<string, number> }>()(z.object({ m: z.custom<Map<string, string>>() }));
+});
+
 test("checks", () => {
   const _a: z.core.$ZodCheck = {} as any as z.core.$ZodChecks;
   const _b: z.core.$ZodCheck = {} as any as z.core.$ZodStringFormatChecks;
   const _c: z.core.$ZodType = {} as any as z.core.$ZodTypes;
   const _d: z.core.$ZodType = {} as any as z.core.$ZodStringFormatTypes;
+  z.currencyCode() satisfies z.core.$ZodStringFormatTypes;
 });
 
 test("assignability to $ZodType", () => {

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

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -52,3 +52,38 @@ test("min max getters", () => {
   expect(z.bigint().max(BigInt(5)).maxValue).toEqual(BigInt(5));
   expect(z.bigint().max(BigInt(5)).max(BigInt(1)).maxValue).toEqual(BigInt(1));
 });
+
+test("a format check applied after min/max does not widen minValue/maxValue back out", () => {
+  const schema = z.bigint().min(0n).max(23n).check(z.int64());
+  expect(schema.minValue).toEqual(0n);
+  expect(schema.maxValue).toEqual(23n);
+});
+
+test("bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
+  expectTypeOf(z.uint64()._zod.def.format).toEqualTypeOf<"uint64">();
+
+  z.int64() satisfies z.ZodBigIntFormat;
+  z.int64() satisfies z.ZodBigInt;
+
+  // @ts-expect-error a uint64 schema is not a ZodInt64
+  z.uint64() satisfies z.ZodInt64;
+});
+
+test("multipleOf(0n) does not throw from safeParse", () => {
+  // `value % 0n` throws RangeError, so the compiled path declines and the runtime reports the failure
+  const schema = z.bigint().multipleOf(BigInt(0));
+  const result = schema.safeParse(BigInt(10));
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].code).toEqual("not_multiple_of");
+  expect(schema.safeParse(BigInt(0)).success).toBe(false);
+
+  // matches the number equivalent
+  expect(z.number().multipleOf(0).safeParse(10).success).toBe(false);
+  expect(z.number().multipleOf(0).safeParse(0).success).toBe(false);
+
+  // a zero divisor nested in an object must not break the surrounding parse
+  const obj = z.object({ a: z.bigint().multipleOf(BigInt(0)), b: z.bigint() });
+  expect(obj.safeParse({ a: BigInt(1), b: BigInt(2) }).success).toBe(false);
+  expect(obj.safeParse({ a: BigInt(1), b: 2 }).success).toBe(false);
+});

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

@@ -253,6 +253,136 @@ test("ctx.input", () => {
   expect(schema.parse(123)).toEqual("123");
 });
 
+test("ctx.value is the input to the catch, not what the inner schema made of it", async () => {
+  const seen: unknown[] = [];
+  const cb = (ctx: z.core.$ZodCatchCtx) => {
+    seen.push(ctx.value, ctx.input);
+    return -1;
+  };
+
+  expect(z.coerce.number().min(10).catch(cb).parse("5")).toBe(-1);
+  expect(
+    await z.coerce
+      .number()
+      .refine(async (n) => n >= 10)
+      .catch(cb)
+      .parseAsync("6")
+  ).toBe(-1);
+  expect(
+    z
+      .string()
+      .transform((s) => s.length)
+      .refine((n) => n > 10)
+      .catch(cb)
+      .parse("abc")
+  ).toBe(-1);
+
+  expect(seen).toEqual(["5", "5", "6", "6", "abc", "abc"]);
+});
+
+test("ctx.issues outlives the callback", () => {
+  let stashed!: z.core.$ZodRawIssue[];
+  z.string()
+    .min(10)
+    .catch((ctx) => {
+      stashed = ctx.issues;
+      return "fallback";
+    })
+    .parse("hi");
+
+  expect(stashed).toHaveLength(1);
+  expect(stashed[0].code).toBe("too_small");
+});
+
+test("catch ctx carries the rest of the payload through", () => {
+  let seen!: z.core.$ZodCatchCtx;
+  z.string()
+    .min(10)
+    .pipe(z.string())
+    .catch((ctx) => {
+      seen = ctx;
+      return "fallback";
+    })
+    .parse("hi");
+
+  expect(seen.aborted).toBe(true);
+});
+
+test("catch does not swallow an issue it did not cause", () => {
+  // A pipe hands its `out` schema the caller's issues array so an unrecognized key can survive to an enclosing intersection. The catch must not read that as its own inner failing.
+  const result = z.strictObject({ a: z.string() }).pipe(z.any().catch("CAUGHT")).safeParse({ a: "x", extra: 1 });
+
+  expect(result.success).toBe(false);
+  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
+});
+
+test("catch does not break intersection reconciliation", () => {
+  // Forwarding the unrecognized key is what lets the intersection reconcile it. A catch that fired on it substituted its fallback into one side, and the merge threw out of safeParse.
+  const schema = z.intersection(
+    z.strictObject({ a: z.string() }).pipe(z.any().catch("CAUGHT")),
+    z.strictObject({ b: z.string() })
+  );
+
+  expect(schema.parse({ a: "x", b: "y" })).toEqual({ a: "x", b: "y" });
+});
+
+test("catch propagates a back-edge to whatever wraps it", () => {
+  // The memoizer marks a payload whose value is a node still being parsed. That mark has to survive the catch: an enclosing readonly must not freeze a half-built object, and the node's checks belong to the node itself rather than to the back-edge.
+  const Node: any = z.object({
+    get self() {
+      return z
+        .lazy(() => Node)
+        .catch(null)
+        .readonly()
+        .optional();
+    },
+  });
+  const cyclic: any = {};
+  cyclic.self = cyclic;
+  const frozen = Node.safeParse(cyclic);
+  expect(frozen.success).toBe(true);
+  expect(Object.keys(frozen.data)).toEqual(["self"]);
+
+  let checks = 0;
+  const Checked: any = z.object({
+    get self() {
+      return z
+        .lazy(() => Checked)
+        .catch(null)
+        .refine(() => {
+          checks++;
+          return true;
+        })
+        .optional();
+    },
+  });
+  const cyclic2: any = {};
+  cyclic2.self = cyclic2;
+  Checked.safeParse(cyclic2);
+  expect(checks).toBe(0);
+});
+
+test("a catch that fires does not rescue an issue from outside it", () => {
+  // The callback still runs and still computes its fallback — the inner schema really did fail. What it cannot do is answer for the unrecognized key the pipe forwarded past it, so the parse fails anyway.
+  let fired = 0;
+  const result = z
+    .strictObject({ a: z.string() })
+    .pipe(
+      z
+        .object({ a: z.string() })
+        .refine(() => false)
+        .catch(() => {
+          fired++;
+          return { a: "FALLBACK" };
+        })
+    )
+    .safeParse({ a: "x", extra: 1 });
+
+  expect(fired).toBe(1);
+  expect(result.success).toBe(false);
+  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
+});
+
 test("direction-aware catch", () => {
   const schema = z.string().catch("fallback");
 
@@ -324,3 +454,151 @@ test("optional clobbers catch through pipe boundaries", () => {
       .parse(123)
   ).toBe("X!");
 });
+
+test("catch does not resurrect issues an inner optional already resolved", () => {
+  // `.catch()` reads issues off the payload it passed down, so an optional that resolved a failure without clearing that array let the failure resurface. The pipe rows matter: a pipe shares the array with a different payload object.
+  const chains: [string, () => z.ZodType][] = [
+    [
+      "prefault.optional",
+      () =>
+        z
+          .undefined()
+          .prefault(null as any)
+          .optional(),
+    ],
+    [
+      "default.optional",
+      () =>
+        z
+          .undefined()
+          .default(null as any)
+          .optional(),
+    ],
+    ["prefault.pipe.optional", () => z.string().prefault("abc").pipe(z.string().min(10)).optional()],
+    ["default.pipe.optional", () => z.string().default("abc").pipe(z.string().min(10)).optional()],
+    [
+      "prefault.optional.optional",
+      () =>
+        z
+          .undefined()
+          .prefault(null as any)
+          .optional()
+          .optional(),
+    ],
+    [
+      "prefault.pipe.optional.optional",
+      () => z.string().prefault("abc").pipe(z.string().min(10)).optional().optional(),
+    ],
+  ];
+
+  for (const [name, make] of chains) {
+    expect(make().safeParse(undefined).success, `${name} without catch`).toBe(true);
+    expect((make() as any).catch(null).safeParse(undefined).success, `${name} + catch(value)`).toBe(true);
+    expect((make() as any).catch(() => null).safeParse(undefined).success, `${name} + catch(callback)`).toBe(true);
+  }
+
+  expect(
+    z
+      .object({
+        a: z
+          .undefined()
+          .prefault(null as any)
+          .optional()
+          .catch(null as any),
+      })
+      .safeParse({ a: undefined }).success
+  ).toBe(true);
+
+  expect(z.string().catch("FB").parse(123)).toBe("FB");
+  expect(z.string().optional().safeParse(123).success).toBe(false);
+});
+
+test("resolving an optional's failure clears the abort flag with it", () => {
+  // A pipe marks the payload aborted when its `in` fails, and `util.aborted` tests that flag alone, so leaving it set skips every check after the optional.
+  const schema = z
+    .string()
+    .min(10)
+    .prefault("abc")
+    .pipe(z.string())
+    .optional()
+    .refine(() => false, "REFINE RAN");
+
+  const result = schema.safeParse(undefined);
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0]?.message).toBe("REFINE RAN");
+});
+
+test("catch clears the abort flag along with the issues", () => {
+  // Same as the optional case one wrapper over: a catch that clears only the issues leaves the flag set, skipping every check after it.
+  const schema = z
+    .string()
+    .min(10)
+    .pipe(z.string())
+    .catch("FB")
+    .refine(() => false, "REFINE RAN");
+
+  const result = schema.safeParse("abc");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0]?.message).toBe("REFINE RAN");
+
+  expect(
+    z
+      .string()
+      .min(2)
+      .pipe(z.string())
+      .catch("FB")
+      .refine(() => false, "REFINE RAN")
+      .safeParse("abcdef").success
+  ).toBe(false);
+  expect(
+    z
+      .string()
+      .min(10)
+      .catch("FB")
+      .refine(() => false, "REFINE RAN")
+      .safeParse("abc").success
+  ).toBe(false);
+});
+
+test("catch clears the abort flag on the async branch too", () => {
+  // Reaching the async branch needs the catch's own inner to be async; an async refinement outside it leaves the inner sync.
+  const schema = z
+    .string()
+    .refine(async () => false, "INNER")
+    .pipe(z.string())
+    .catch("FB")
+    .refine(() => false, "REFINE RAN");
+
+  return expect(schema.safeParseAsync("abc")).resolves.toMatchObject({
+    success: false,
+    error: { issues: [{ message: "REFINE RAN" }] },
+  });
+});
+
+test("catch resolves the issues array itself, so an outer catch does not resurrect them", () => {
+  // A pipe runs its `out` on a payload sharing the caller's issues array, so a catch that rebinds its own reference leaves the caller's copy dirty.
+  const inner = z.string().pipe(z.string().min(10).catch("FB"));
+
+  expect(inner.safeParse("abc")).toMatchObject({ success: true, data: "FB" });
+  expect(inner.catch("FB2").safeParse("abc")).toMatchObject({ success: true, data: "FB" });
+
+  expect(z.string().catch("FB").parse(123)).toBe("FB");
+  expect(z.string().catch("FB").parse("ok")).toBe("ok");
+  expect(
+    z
+      .string()
+      .catch((ctx) => `n=${ctx.error.issues.length}`)
+      .parse(123)
+  ).toBe("n=1");
+});
+
+test("catch resolves the issues array on the async branch too", () => {
+  const inner = z.string().pipe(
+    z
+      .string()
+      .refine(async () => false, "INNER")
+      .catch("FB")
+  );
+
+  return expect(inner.catch("FB2").safeParseAsync("abc")).resolves.toMatchObject({ success: true, data: "FB" });
+});

package/node_modules/zod/src/v4/classic/tests/codec-examples.test.ts

@@ -554,8 +554,7 @@ test("codec transform error handling", () => {
     expect(validResult.data).toEqual({ valid: "json" });
   }
 
-  // Test invalid JSON that should create a single "invalid_format" issue
-  // Verifies that the transform error aborts before reaching the output schema
+  // Test invalid JSON that should create a single "invalid_format" issue. Verifies that the transform error aborts before reaching the output schema
   const invalidResult = z.safeDecode(anyJSON, '{"invalid":,}');
   expect(invalidResult.success).toBe(false);
   if (!invalidResult.success) {

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

@@ -100,7 +100,7 @@ test("safe codec operations", () => {
           "message": "Invalid ISO datetime",
           "origin": "string",
           "path": [],
-          "pattern": "/^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$/",
+          "pattern": "/^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$/",
         },
       ]
     `);
@@ -241,6 +241,7 @@ test("nested codec with object containing codec property", () => {
   `);
 
   // Test refinements at all levels
+
   // String validation (empty waypoint name)
   const emptyNameResult = z.safeDecode(waypointSchema, {
     name: "",

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

@@ -40,7 +40,7 @@ test("continuability", () => {
         "message": "Invalid email address",
         "origin": "string",
         "path": [],
-        "pattern": "/^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
+        "pattern": "/^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
       },
       {
         "code": "custom",
@@ -230,7 +230,7 @@ test("continuability", () => {
         "message": "Invalid emoji",
         "origin": "string",
         "path": [],
-        "pattern": "/^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$/u",
+        "pattern": "/^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$/u",
       },
       {
         "code": "custom",
@@ -318,7 +318,7 @@ test("continuability", () => {
         "message": "Invalid ULID",
         "origin": "string",
         "path": [],
-        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
+        "pattern": "/^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/",
       },
       {
         "code": "custom",