@loomhelm/multi-task-flow 0.2.7 → 0.2.9

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v4/classic/tests/optin-ladder.test.ts

@@ -1,235 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-/* ------------------------------------------------------------------ *
- * TYPE-LEVEL — the dangerous half. Defaults must stay OPTIONAL in
- * z.input and REQUIRED in z.output, exactly as before the ladder.
- * ------------------------------------------------------------------ */
-test("ladder: z.input / z.output unchanged by the extra rung", () => {
-  const objDefault = z.object({ a: z.string().default("D"), b: z.number() });
-  expectTypeOf<z.input<typeof objDefault>>().toEqualTypeOf<{ a?: string | undefined; b: number }>();
-  expectTypeOf<z.output<typeof objDefault>>().toEqualTypeOf<{ a: string; b: number }>();
-
-  const objPrefault = z.object({ a: z.string().prefault("P"), b: z.number() });
-  expectTypeOf<z.input<typeof objPrefault>>().toEqualTypeOf<{ a?: string | undefined; b: number }>();
-  expectTypeOf<z.output<typeof objPrefault>>().toEqualTypeOf<{ a: string; b: number }>();
-
-  const objOptional = z.object({ a: z.string().optional() });
-  expectTypeOf<z.input<typeof objOptional>>().toEqualTypeOf<{ a?: string | undefined }>();
-
-  const objTransform = z.object({
-    a: z
-      .string()
-      .default("")
-      .transform((v) => v.length),
-  });
-  expectTypeOf<z.input<typeof objTransform>>().toEqualTypeOf<{ a?: string | undefined }>();
-  expectTypeOf<z.output<typeof objTransform>>().toEqualTypeOf<{ a: number }>();
-
-  const standalone = z.string().default("D");
-  expectTypeOf<z.input<typeof standalone>>().toEqualTypeOf<string | undefined>();
-  expectTypeOf<z.output<typeof standalone>>().toEqualTypeOf<string>();
-
-  // a trailing defaulted tuple slot stays optional in the input tuple
-  const tup = z.tuple([z.string(), z.number().default(1)]);
-  expectTypeOf<z.input<typeof tup>>().toEqualTypeOf<[string, (number | undefined)?]>();
-
-  const partialed = objDefault.partial();
-  expectTypeOf<z.input<typeof partialed>>().toEqualTypeOf<{ a?: string | undefined; b?: number | undefined }>();
-});
-
-/* ------------------------------------------------------------------ *
- * RUNTIME
- * ------------------------------------------------------------------ */
-test("ladder: the #6321 regression is fixed", () => {
-  const arr = z
-    .string()
-    .default("")
-    .transform((v) => (v ? v.split(",") : []));
-  expect(z.object({ a: arr }).partial().parse({})).toEqual({ a: [] });
-  expect(z.object({ a: arr }).partial().parse({ a: undefined })).toEqual({ a: [] });
-  expect(z.object({ a: arr }).partial().parse({ a: "x,y" })).toEqual({ a: ["x", "y"] });
-  expect(arr.optional().parse(undefined)).toEqual([]);
-  expect(
-    z
-      .string()
-      .prefault("hi")
-      .transform((v) => v.length)
-      .optional()
-      .parse(undefined)
-  ).toBe(2);
-});
-
-test("ladder: key-level admissibility across every rung", () => {
-  expect(z.object({ a: z.string().default("D") }).parse({})).toEqual({ a: "D" });
-  expect(z.object({ a: z.string().prefault("P") }).parse({})).toEqual({ a: "P" });
-  expect(z.object({ a: z.string().optional() }).parse({})).toEqual({});
-  expect(z.object({ a: z.transform(() => "T") }).parse({})).toEqual({ a: "T" });
-  expect(z.object({ a: z.string().catch("C") }).parse({})).toEqual({ a: "C" });
-  expect(z.object({ a: z.string() }).safeParse({}).success).toBe(false);
-});
-
-test("ladder: exactOptional keeps its distinct meaning", () => {
-  expect(z.object({ a: z.string().exactOptional() }).parse({})).toEqual({});
-  expect(z.object({ a: z.string().exactOptional() }).safeParse({ a: undefined }).success).toBe(false);
-});
-
-// An absent key never materializes a value from a schema that only claims the middle rung, however that schema answers `undefined`. The top rung still substitutes, and an explicitly present `undefined` still runs the inner.
-test.each([true, false])("ladder: an absent key stays absent on the middle rung (jitless=%s)", (jitless) => {
-  const opts = { jitless };
-  expect(z.object({ a: z.coerce.string().exactOptional() }).parse({}, opts)).toStrictEqual({});
-  expect(z.object({ a: z.string().catch("C").exactOptional() }).parse({}, opts)).toStrictEqual({});
-  expect(z.object({ a: z.preprocess((v) => v ?? "X", z.string()).exactOptional() }).parse({}, opts)).toStrictEqual({});
-  expect(z.object({ a: z.union([z.coerce.string(), z.string().optional()]) }).parse({}, opts)).toStrictEqual({});
-
-  expect(z.object({ a: z.string().default("D").exactOptional() }).parse({}, opts)).toStrictEqual({ a: "D" });
-  expect(z.object({ a: z.string().prefault("P").exactOptional() }).parse({}, opts)).toStrictEqual({ a: "P" });
-  expect(z.object({ a: z.coerce.string().exactOptional() }).parse({ a: undefined }, opts)).toStrictEqual({
-    a: "undefined",
-  });
-  expect(z.object({ a: z.coerce.string() }).parse({ a: undefined }, opts)).toStrictEqual({ a: "undefined" });
-});
-
-test("ladder: an absent tuple slot on the middle rung truncates the tail", () => {
-  expect(z.tuple([z.string(), z.coerce.string().exactOptional()]).parse(["x"])).toStrictEqual(["x"]);
-  expect(z.tuple([z.string(), z.string().catch("C").exactOptional()]).parse(["x"])).toStrictEqual(["x"]);
-  expect(z.tuple([z.string(), z.string().default("D").exactOptional()]).parse(["x"])).toStrictEqual(["x", "D"]);
-});
-
-// z.compile() assembles its own output, so the gate has to be mirrored there or compile mode silently keeps the invented value.
-test("ladder: compile mode agrees with the interpreted and JIT paths on absent middle-rung slots", () => {
-  const objects = [
-    [z.object({ a: z.coerce.string().exactOptional() }), {}],
-    [z.object({ a: z.string().catch("C").exactOptional() }), {}],
-    [z.object({ a: z.string().default("D").exactOptional() }), { a: "D" }],
-    [z.object({ a: z.string().catch("C") }), { a: "C" }],
-  ] as const;
-  for (const [schema, expected] of objects) {
-    expect(z.compile(schema).parse({})).toStrictEqual(expected);
-    expect(schema.parse({}, { jitless: true })).toStrictEqual(expected);
-    expect(schema.parse({})).toStrictEqual(expected);
-  }
-
-  const tuples = [
-    [z.tuple([z.string(), z.coerce.string().exactOptional()]), ["x"]],
-    [z.tuple([z.string(), z.string().default("D").exactOptional()]), ["x", "D"]],
-  ] as const;
-  for (const [schema, expected] of tuples) {
-    expect(z.compile(schema).parse(["x"])).toStrictEqual(expected);
-    expect(schema.parse(["x"], { jitless: true })).toStrictEqual(expected);
-  }
-});
-
-test("ladder: tuple minimum length respects every rung", () => {
-  expect(z.tuple([z.string().default("D")]).parse([])).toEqual(["D"]);
-  expect(z.tuple([z.string().prefault("P")]).parse([])).toEqual(["P"]);
-  expect(z.tuple([z.string().optional()]).parse([])).toEqual([]);
-  expect(z.tuple([z.string()]).safeParse([]).success).toBe(false);
-  expect(z.tuple([z.string(), z.number().default(1)]).parse(["x"])).toEqual(["x", 1]);
-});
-
-test("ladder: the #5941 / #5939 clobber invariants still hold", () => {
-  expect(
-    z
-      .preprocess((v) => v ?? "X", z.string())
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(z.string().catch("X").optional().parse(undefined)).toBeUndefined();
-  expect(
-    z
-      .string()
-      .catch("X")
-      .transform((s) => `${s}!`)
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(
-    z
-      .transform(() => "T")
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(
-    z
-      .union([z.preprocess((v) => v ?? "X", z.string()), z.number()])
-      .optional()
-      .parse(undefined)
-  ).toBeUndefined();
-  expect(z.object({ a: z.preprocess((v) => v ?? "X", z.string()) }).parse({})).toEqual({ a: "X" });
-});
-
-test("ladder: the top rung survives every wrapper order", () => {
-  expect(z.string().default("D").optional().parse(undefined)).toBe("D");
-  expect(z.string().default("D").optional().optional().parse(undefined)).toBe("D");
-  expect(z.string().default("D").nullable().optional().parse(undefined)).toBe("D");
-  expect(z.string().default("D").readonly().optional().parse(undefined)).toBe("D");
-  expect(z.string().default("D").catch("C").optional().parse(undefined)).toBe("D");
-  expect(z.string().default("D").pipe(z.string()).optional().parse(undefined)).toBe("D");
-  expect(
-    z
-      .union([z.string().default("D"), z.number()])
-      .optional()
-      .parse(undefined)
-  ).toBe("D");
-  expect(
-    z
-      .lazy(() => z.string().default("D"))
-      .optional()
-      .parse(undefined)
-  ).toBe("D");
-});
-
-test("ladder: record and catchall paths that read optin", () => {
-  expect(z.record(z.string(), z.string().default("D")).parse({ k: undefined })).toEqual({ k: "D" });
-  expect(z.object({}).catchall(z.string().default("D")).parse({ x: undefined })).toEqual({ x: "D" });
-});
-
-test("ladder: async parity", async () => {
-  const a = z
-    .string()
-    .default("")
-    .transform(async (v) => (v ? v.split(",") : []));
-  expect((await a.optional().safeParseAsync(undefined)).data).toEqual([]);
-  expect((await z.object({ a }).partial().safeParseAsync({})).data).toEqual({ a: [] });
-  expect(
-    (
-      await z
-        .preprocess(async (v) => v ?? "X", z.string())
-        .optional()
-        .safeParseAsync(undefined)
-    ).data
-  ).toBeUndefined();
-});
-
-test("ladder: the rung values themselves", () => {
-  expect(z.string()._zod.optin).toBeUndefined();
-  expect(z.string().optional()._zod.optin).toBe("optional");
-  expect(z.transform(() => 1)._zod.optin).toBe("optional");
-  expect(z.string().catch("C")._zod.optin).toBe("optional");
-  expect(z.string().default("D")._zod.optin).toBe("defaulted");
-  expect(z.string().prefault("P")._zod.optin).toBe("defaulted");
-  expect(
-    z
-      .string()
-      .default("D")
-      .transform((v) => v)._zod.optin
-  ).toBe("defaulted");
-  expect(z.string().default("D").optional()._zod.optin).toBe("defaulted");
-  expect(z.union([z.string().default("D"), z.number()])._zod.optin).toBe("defaulted");
-  expect(z.union([z.string().optional(), z.number()])._zod.optin).toBe("optional");
-});
-
-test("exactOptional overrides the values and pattern optional installs", () => {
-  expect(z.exactOptional(z.enum(["a", "b"]))._zod.values).toEqual(new Set(["a", "b"]));
-  // a format carries its pattern on its def; a chained `.regex()` no longer folds into the inner `_zod.pattern`, the template literal derives that itself
-  expect(z.exactOptional(z.stringFormat("abc", /^abc$/))._zod.pattern).toEqual(/^abc$/);
-  expect(z.templateLiteral(["a", z.exactOptional(z.literal("b"))]).safeParse("a").success).toEqual(false);
-});
-
-// The override is installed once, on a prototype every instance of the type shares, so it has to hold for instances built after the first.
-test("exactOptional's override holds for later instances", () => {
-  z.exactOptional(z.enum(["a", "b"]));
-  expect(z.exactOptional(z.enum(["c", "d"]))._zod.values).toEqual(new Set(["c", "d"]));
-  expect(z.exactOptional(z.stringFormat("xyz", /^xyz$/))._zod.pattern).toEqual(/^xyz$/);
-});

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v4/classic/tests/optional.test.ts

@@ -1,366 +0,0 @@
-// @ts-ignore TS6133
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test(".optional()", () => {
-  const schema = z.string().optional();
-  expect(schema.parse("adsf")).toEqual("adsf");
-  expect(schema.parse(undefined)).toEqual(undefined);
-  expect(schema.safeParse(null).success).toEqual(false);
-
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<string | undefined>();
-});
-
-test("unwrap", () => {
-  const unwrapped = z.string().optional().unwrap();
-  expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-
-test("optionality", () => {
-  const a = z.string();
-  expect(a._zod.optin).toEqual(undefined);
-  expect(a._zod.optout).toEqual(undefined);
-
-  const b = z.string().optional();
-  expect(b._zod.optin).toEqual("optional");
-  expect(b._zod.optout).toEqual("optional");
-
-  const c = z.string().default("asdf");
-  expect(c._zod.optin).toEqual("defaulted");
-  expect(c._zod.optout).toEqual(undefined);
-
-  const d = z.string().optional().nullable();
-  expect(d._zod.optin).toEqual("optional");
-  expect(d._zod.optout).toEqual("optional");
-
-  const e = z.string().default("asdf").nullable();
-  expect(e._zod.optin).toEqual("defaulted");
-  expect(e._zod.optout).toEqual(undefined);
-
-  // z.undefined should NOT be optional
-  const f = z.undefined();
-  expect(f._zod.optin).toEqual(undefined);
-  expect(f._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
-  expectTypeOf<typeof f._zod.optout>().toEqualTypeOf<"optional" | undefined>();
-
-  // z.union should be optional if any of the types are optional
-  const g = z.union([z.string(), z.undefined()]);
-  expect(g._zod.optin).toEqual(undefined);
-  expect(g._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
-  expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();
-
-  const h = z.union([z.string(), z.optional(z.string())]);
-  expect(h._zod.optin).toEqual("optional");
-  expect(h._zod.optout).toEqual("optional");
-  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
-  expectTypeOf<typeof h._zod.optout>().toEqualTypeOf<"optional">();
-});
-
-test("pipe optionality", () => {
-  z.string().optional()._zod.optin;
-  const a = z.string().optional().pipe(z.string());
-  expect(a._zod.optin).toEqual("optional");
-  expect(a._zod.optout).toEqual(undefined);
-  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
-  expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional" | undefined>();
-
-  const b = z
-    .string()
-    .transform((val) => (Math.random() ? val : undefined))
-    .pipe(z.string().optional());
-  expect(b._zod.optin).toEqual(undefined);
-  expect(b._zod.optout).toEqual("optional");
-  expectTypeOf<typeof b._zod.optin>().toEqualTypeOf<"optional" | "defaulted" | undefined>();
-  expectTypeOf<typeof b._zod.optout>().toEqualTypeOf<"optional">();
-
-  const c = z.string().default("asdf").pipe(z.string());
-  expect(c._zod.optin).toEqual("defaulted");
-  expect(c._zod.optout).toEqual(undefined);
-
-  const d = z
-    .string()
-    .transform((val) => (Math.random() ? val : undefined))
-    .pipe(z.string().default("asdf"));
-  expect(d._zod.optin).toEqual(undefined);
-  expect(d._zod.optout).toEqual(undefined);
-});
-
-test("pipe optionality inside objects", () => {
-  const schema = z.object({
-    a: z.string().optional(),
-    b: z.string().optional().pipe(z.string()),
-    c: z.string().default("asdf").pipe(z.string()),
-    d: z
-      .string()
-      .transform((val) => (Math.random() ? val : undefined))
-      .pipe(z.string().optional()),
-    e: z
-      .string()
-      .transform((val) => (Math.random() ? val : undefined))
-      .pipe(z.string().default("asdf")),
-  });
-
-  type SchemaIn = z.input<typeof schema>;
-  expectTypeOf<SchemaIn>().toEqualTypeOf<{
-    a?: string | undefined;
-    b?: string | undefined;
-    c?: string | undefined;
-    d: string;
-    e: string;
-  }>();
-
-  type SchemaOut = z.output<typeof schema>;
-  expectTypeOf<SchemaOut>().toEqualTypeOf<{
-    a?: string | undefined;
-    b: string;
-    c: string;
-    d?: string | undefined;
-    e: string;
-  }>();
-});
-
-test("optional prop with pipe", () => {
-  const schema = z.object({
-    id: z
-      .union([z.number(), z.string().nullish()])
-      .transform((val) => (val === null || val === undefined ? val : Number(val)))
-      .pipe(z.number())
-      .optional(),
-  });
-
-  schema.parse({});
-  schema.parse({}, { jitless: true });
-});
-
-test("object absent keys require optin optional", () => {
-  const valueUndefined = z.object({
-    value: z.undefined(),
-    union: z.union([z.string(), z.undefined()]),
-  });
-
-  expect(valueUndefined.safeParse({}).error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "message": "Invalid input: expected nonoptional, received undefined",
-        "path": [
-          "value",
-        ],
-      },
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "message": "Invalid input: expected nonoptional, received undefined",
-        "path": [
-          "union",
-        ],
-      },
-    ]
-  `);
-  expect(valueUndefined.safeParse({}, { jitless: true }).success).toEqual(false);
-  expect(valueUndefined.parse({ value: undefined, union: undefined })).toEqual({
-    value: undefined,
-    union: undefined,
-  });
-
-  const optionalOutOnly = z.object({
-    value: z
-      .string()
-      .transform((val) => (Math.random() ? val : undefined))
-      .pipe(z.string().optional()),
-  });
-  expect(optionalOutOnly.safeParse({}).success).toEqual(false);
-  expect(optionalOutOnly.safeParse({}, { jitless: true }).success).toEqual(false);
-
-  const defaulted = z.object({ value: z.string().default("fallback") });
-  expect(defaulted.parse({})).toEqual({ value: "fallback" });
-  expect(defaulted.parse({}, { jitless: true })).toEqual({ value: "fallback" });
-});
-
-// exactOptional tests
-test(".exactOptional()", () => {
-  const schema = z.string().exactOptional();
-  expect(schema.parse("asdf")).toEqual("asdf");
-  expect(schema.safeParse(undefined).success).toEqual(false);
-  expect(schema.safeParse(null).success).toEqual(false);
-
-  // Type should NOT include undefined
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<string>();
-  expectTypeOf<typeof schema._input>().toEqualTypeOf<string>();
-});
-
-test("exactOptional unwrap", () => {
-  const unwrapped = z.string().exactOptional().unwrap();
-  expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-
-test("exactOptional optionality", () => {
-  const a = z.string().exactOptional();
-  expect(a._zod.optin).toEqual("optional");
-  expect(a._zod.optout).toEqual("optional");
-  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional" | "defaulted">();
-  expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional">();
-});
-
-test("exactOptional in objects - absent keys", () => {
-  const schema = z.object({
-    a: z.string().exactOptional(),
-  });
-
-  // Absent key should pass
-  expect(schema.parse({})).toEqual({});
-  expect(schema.parse({}, { jitless: true })).toEqual({});
-
-  // Present key with valid value should pass
-  expect(schema.parse({ a: "hello" })).toEqual({ a: "hello" });
-  expect(schema.parse({ a: "hello" }, { jitless: true })).toEqual({ a: "hello" });
-});
-
-test("exactOptional in objects - explicit undefined rejected", () => {
-  const schema = z.object({
-    a: z.string().exactOptional(),
-  });
-
-  // Explicit undefined should fail
-  expect(schema.safeParse({ a: undefined }).success).toEqual(false);
-  expect(schema.safeParse({ a: undefined }, { jitless: true }).success).toEqual(false);
-});
-
-test("exactOptional type inference in objects", () => {
-  const schema = z.object({
-    a: z.string().exactOptional(),
-    b: z.string().optional(),
-  });
-
-  type SchemaIn = z.input<typeof schema>;
-  expectTypeOf<SchemaIn>().toEqualTypeOf<{
-    a?: string;
-    b?: string | undefined;
-  }>();
-
-  type SchemaOut = z.output<typeof schema>;
-  expectTypeOf<SchemaOut>().toEqualTypeOf<{
-    a?: string;
-    b?: string | undefined;
-  }>();
-});
-
-test("exactOptional vs optional comparison", () => {
-  const optionalSchema = z.object({ a: z.string().optional() });
-  const exactOptionalSchema = z.object({ a: z.string().exactOptional() });
-
-  // Both accept absent keys
-  expect(optionalSchema.parse({})).toEqual({});
-  expect(exactOptionalSchema.parse({})).toEqual({});
-
-  // Both accept valid values
-  expect(optionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" });
-  expect(exactOptionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" });
-
-  // optional() accepts explicit undefined
-  expect(optionalSchema.parse({ a: undefined })).toEqual({ a: undefined });
-
-  // exactOptional() rejects explicit undefined
-  expect(exactOptionalSchema.safeParse({ a: undefined }).success).toEqual(false);
-});
-
-// Defensive inference coverage: every schema that propagates `optout` participates in object-key optionality inference. If anyone ever changes the set of values that `optout` can take (or how OptionalOutSchema matches them), these assertions must continue to hold or downstream `z.infer<typeof obj>` types silently flip required keys.
-test("object key optionality through optout propagation", () => {
-  const direct = z.object({ k: z.string().optional() });
-  expectTypeOf<z.infer<typeof direct>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  const exact = z.object({ k: z.string().exactOptional() });
-  expectTypeOf<z.infer<typeof exact>>().toEqualTypeOf<{ k?: string }>();
-
-  // nullable() preserves the inner type's optout
-  const nullableOpt = z.object({ k: z.string().optional().nullable() });
-  expectTypeOf<z.infer<typeof nullableOpt>>().toEqualTypeOf<{ k?: string | null | undefined }>();
-
-  // optional() wrapping nullable() — still optional out
-  const optNullable = z.object({ k: z.string().nullable().optional() });
-  expectTypeOf<z.infer<typeof optNullable>>().toEqualTypeOf<{ k?: string | null | undefined }>();
-
-  // union containing an optional member must mark the key as optional
-  const unionWithOpt = z.object({ k: z.union([z.string(), z.string().optional()]) });
-  expectTypeOf<z.infer<typeof unionWithOpt>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  // pipe ending in optional()
-  const pipedToOpt = z.object({
-    k: z
-      .string()
-      .transform((v) => (Math.random() ? v : undefined))
-      .pipe(z.string().optional()),
-  });
-  expectTypeOf<z.output<typeof pipedToOpt>>().toEqualTypeOf<{ k?: string | undefined }>();
-
-  // mixed shape pinning required vs optional keys end-to-end
-  const mixed = z.object({
-    req: z.string(),
-    opt: z.string().optional(),
-    exact: z.string().exactOptional(),
-    def: z.string().default("x"),
-    nullableOpt: z.string().optional().nullable(),
-  });
-  expectTypeOf<z.output<typeof mixed>>().toEqualTypeOf<{
-    req: string;
-    opt?: string | undefined;
-    exact?: string;
-    def: string;
-    nullableOpt?: string | null | undefined;
-  }>();
-});
-
-// Defensive: tuple optional-tail inference also reads optout. The PR that introduced `"includeUndefined"` had to update TupleOutputTypeWithOptionals; pin the result so any future flag change has to keep this contract.
-test("tuple tail optionality through optout propagation", () => {
-  const trailingOptional = z.tuple([z.string(), z.number().optional()]);
-  expectTypeOf<z.output<typeof trailingOptional>>().toEqualTypeOf<[string, (number | undefined)?]>();
-
-  const trailingExact = z.tuple([z.string(), z.number().exactOptional()]);
-  expectTypeOf<z.output<typeof trailingExact>>().toEqualTypeOf<[string, number?]>();
-
-  // Interior optional must NOT make the tail optional
-  const interiorOptional = z.tuple([z.string(), z.number().optional(), z.string()]);
-  expectTypeOf<z.output<typeof interiorOptional>>().toEqualTypeOf<[string, number | undefined, string]>();
-});
-
-// An absent optional key whose check fails has its issue swallowed; the value the check wrote must go with it, on the JIT fastpass as well as the interpreted path.
-test("swallowed issue on an absent optional key drops its value", async () => {
-  const schema = z.object({
-    a: z
-      .string()
-      .optional()
-      .superRefine((_v, ctx) => {
-        ctx.addIssue({ code: "custom", message: "bad" });
-        ctx.value = "leaked";
-      }),
-  });
-
-  for (const result of [
-    schema.safeParse({}),
-    schema.safeParse({}, { jitless: true }),
-    await schema.safeParseAsync({}),
-  ]) {
-    expect(result.success).toEqual(true);
-    expect("a" in result.data!).toEqual(false);
-  }
-
-  // A present key keeps both the issue and its value.
-  expect(schema.safeParse({ a: "x" }).success).toEqual(false);
-  expect(schema.safeParse({ a: "x" }, { jitless: true }).success).toEqual(false);
-});
-
-test("optional 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. A defaulted inner substituting for absence must not read that as its own failing and drop it.
-  const result = z
-    .strictObject({ a: z.string() })
-    .transform((): number | undefined => undefined)
-    .pipe(z.number().default(5).optional())
-    .safeParse({ a: "x", extra: 1 });
-
-  expect(result.success).toBe(false);
-  expect(result.error!.issues.map((i) => i.code)).toEqual(["unrecognized_keys"]);
-});