agent-relay 6.0.3 → 6.0.5

package/node_modules/@relaycast/sdk/node_modules/zod/src/v4/classic/tests/to-json-schema.test.ts

@@ -212,7 +212,7 @@ describe("toJSONSchema", () => {
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
         "format": "cuid",
-        "pattern": "^[cC][^\\s-]{8,}$",
+        "pattern": "^[cC][0-9a-z]{6,}$",
         "type": "string",
       }
     `);
@@ -647,6 +647,47 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("number constraints intersection draft-04", () => {
+    // When both minimum (from .int()) and exclusiveMinimum (from .positive()) exist,
+    // the more restrictive constraint should be used
+    expect(z.toJSONSchema(z.number().int().positive().lte(65535), { target: "draft-04" })).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema#",
+        "exclusiveMinimum": true,
+        "maximum": 65535,
+        "minimum": 0,
+        "type": "integer",
+      }
+    `);
+    // Same for openapi-3.0
+    expect(z.toJSONSchema(z.number().int().positive().lte(65535), { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+      {
+        "exclusiveMinimum": true,
+        "maximum": 65535,
+        "minimum": 0,
+        "type": "integer",
+      }
+    `);
+    // When inclusive minimum is more restrictive than exclusive minimum
+    expect(z.toJSONSchema(z.number().gt(3).gte(10), { target: "draft-04" })).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema#",
+        "minimum": 10,
+        "type": "number",
+      }
+    `);
+    // Same logic for maximum constraints
+    expect(z.toJSONSchema(z.number().int().negative(), { target: "draft-04" })).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-04/schema#",
+        "exclusiveMaximum": true,
+        "maximum": 0,
+        "minimum": -9007199254740991,
+        "type": "integer",
+      }
+    `);
+  });
+
   test("target normalization draft-04 and draft-07", () => {
     // Test that both old (draft-4, draft-7) and new (draft-04, draft-07) target formats work
     // Test draft-04 / draft-4
@@ -1219,11 +1260,9 @@ describe("toJSONSchema", () => {
         },
         "definitions": {
           "primary": {
-            "id": "primary",
             "type": "string",
           },
           "rest": {
-            "id": "rest",
             "type": "number",
           },
         },
@@ -2014,11 +2053,9 @@ test("extract schemas with id", () => {
     {
       "$defs": {
         "age": {
-          "id": "age",
           "type": "number",
         },
         "name": {
-          "id": "name",
           "type": "string",
         },
       },
@@ -2106,7 +2143,6 @@ test("describe with id", () => {
     {
       "$defs": {
         "jobId": {
-          "id": "jobId",
           "type": "string",
         },
       },
@@ -2131,6 +2167,45 @@ test("describe with id", () => {
   `);
 });
 
+test("id is stripped from $defs entries (draft-2020-12)", () => {
+  // The `id` in `.meta()` is a registration tag — it determines the $defs key
+  // but should not leak into the definition body, where it is redundant.
+  const inner = z.string().meta({ id: "Inner" });
+  const result = z.toJSONSchema(z.object({ a: inner, b: inner }));
+  expect(result.$defs?.Inner).toEqual({ type: "string" });
+  expect((result.$defs?.Inner as any).id).toBeUndefined();
+});
+
+test("id is stripped from definitions entries (draft-04)", () => {
+  // In draft-04, `id` is a reserved keyword that sets a base URI for the
+  // subschema. Leaking Zod's registration tag here is semantically wrong, so
+  // ensure it is stripped.
+  const inner = z.string().meta({ id: "Inner" });
+  const result = z.toJSONSchema(z.object({ a: inner, b: inner }), { target: "draft-04" }) as any;
+  expect(result.definitions?.Inner).toEqual({ type: "string" });
+  expect(result.definitions?.Inner?.id).toBeUndefined();
+});
+
+test("id is stripped from root schema", () => {
+  // The registration tag should not appear on the root either.
+  const A = z.object({ name: z.string() }).meta({ id: "A" });
+  const result = z.toJSONSchema(A);
+  expect((result as any).id).toBeUndefined();
+});
+
+test("id is observable in override callback", () => {
+  // The strip happens after override callbacks run, so userland override code
+  // can still read `jsonSchema.id` if it wants to.
+  const inner = z.string().meta({ id: "Inner" });
+  const seenIds: Array<string | undefined> = [];
+  z.toJSONSchema(z.object({ a: inner }), {
+    override: ({ jsonSchema }) => {
+      if (jsonSchema.id !== undefined) seenIds.push(jsonSchema.id as string);
+    },
+  });
+  expect(seenIds).toContain("Inner");
+});
+
 test("describe with id on wrapper", () => {
   // Test that $ref propagation works when processor sets a different ref (readonly -> innerType)
   // but parent was extracted due to having an id
@@ -2146,7 +2221,6 @@ test("describe with id on wrapper", () => {
     {
       "$defs": {
         "roJobId": {
-          "id": "roJobId",
           "readOnly": true,
           "type": "string",
         },
@@ -2185,12 +2259,10 @@ test("overwrite id", () => {
     {
       "$defs": {
         "aaa": {
-          "id": "aaa",
           "type": "string",
         },
         "bbb": {
           "$ref": "#/$defs/aaa",
-          "id": "bbb",
         },
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -2224,12 +2296,10 @@ test("overwrite id", () => {
     {
       "$defs": {
         "aaa": {
-          "id": "aaa",
           "type": "string",
         },
         "ccc": {
           "$ref": "#/$defs/aaa",
-          "id": "ccc",
         },
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -2351,7 +2421,6 @@ test("top-level readonly", () => {
       "$defs": {
         "B": {
           "additionalProperties": false,
-          "id": "B",
           "properties": {
             "a": {
               "$ref": "#",
@@ -2370,7 +2439,6 @@ test("top-level readonly", () => {
       },
       "$schema": "https://json-schema.org/draft/2020-12/schema",
       "additionalProperties": false,
-      "id": "A",
       "properties": {
         "b": {
           "$ref": "#/$defs/B",
@@ -2497,7 +2565,6 @@ test("_ref", () => {
     {
       "$defs": {
         "foo": {
-          "id": "foo",
           "type": "string",
         },
       },
@@ -2560,6 +2627,38 @@ test("defaults/prefaults", () => {
   `);
 });
 
+test("falsy prefaults (false, 0, empty string)", () => {
+  // boolean prefault false
+  const a = z.boolean().prefault(false);
+  expect(z.toJSONSchema(a, { io: "input" })).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "default": false,
+      "type": "boolean",
+    }
+  `);
+
+  // number prefault 0
+  const b = z.number().prefault(0);
+  expect(z.toJSONSchema(b, { io: "input" })).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "default": 0,
+      "type": "number",
+    }
+  `);
+
+  // string prefault empty string
+  const c = z.string().prefault("");
+  expect(z.toJSONSchema(c, { io: "input" })).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "default": "",
+      "type": "string",
+    }
+  `);
+});
+
 test("input type", () => {
   const schema = z.object({
     a: z.string(),
@@ -2988,3 +3087,18 @@ test("cycle detection - mutual recursion", () => {
     Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.]
   `);
 });
+
+test("recursive lazy with describe does not stack overflow", () => {
+  const NodeSchema: z.ZodType = z.lazy(() =>
+    z
+      .object({
+        value: z.string().describe("node value"),
+        children: z.array(NodeSchema.describe("child node")).optional().describe("child list"),
+      })
+      .describe("tree node")
+  );
+
+  const result = z.toJSONSchema(NodeSchema, { cycles: "ref", reused: "ref" });
+  expect(result).toBeDefined();
+  expect(result.$defs).toBeDefined();
+});

package/node_modules/@relaycast/sdk/node_modules/zod/src/v4/classic/tests/transform.test.ts

@@ -359,3 +359,20 @@ test("encode error", () => {
     `[ZodEncodeError: Encountered unidirectional transform during encode: ZodTransform]`
   );
 });
+
+test("transform context should have addIssue", () => {
+  const schema = z.transform((val, ctx) => {
+    ctx.addIssue({
+      code: "custom",
+      message: "Not valid",
+    });
+    return val;
+  });
+
+  const result = schema.safeParse("test");
+
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    expect(result.error.issues[0].message).toBe("Not valid");
+  }
+});

package/node_modules/@relaycast/sdk/node_modules/zod/src/v4/classic/tests/tuple.test.ts

@@ -107,7 +107,9 @@ test("async validation", async () => {
 
 test("tuple with optional elements", () => {
   const myTuple = z.tuple([z.string(), z.number().optional(), z.string().optional()]).rest(z.boolean());
-  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number?, string?, ...boolean[]]>();
+  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<
+    [string, (number | undefined)?, (string | undefined)?, ...boolean[]]
+  >();
 
   const goodData = [["asdf"], ["asdf", 1234], ["asdf", 1234, "asdf"], ["asdf", 1234, "asdf", true, false, true]];
   for (const data of goodData) {
@@ -149,7 +151,9 @@ test("tuple with optional elements followed by required", () => {
 
 test("tuple with all optional elements", () => {
   const allOptionalTuple = z.tuple([z.string().optional(), z.number().optional(), z.boolean().optional()]);
-  expectTypeOf<typeof allOptionalTuple._output>().toEqualTypeOf<[string?, number?, boolean?]>();
+  expectTypeOf<typeof allOptionalTuple._output>().toEqualTypeOf<
+    [(string | undefined)?, (number | undefined)?, (boolean | undefined)?]
+  >();
 
   // Empty array should be valid (all items optional)
   expect(allOptionalTuple.parse([])).toEqual([]);
@@ -165,6 +169,227 @@ test("tuple with all optional elements", () => {
   expect(() => allOptionalTuple.parse(["hello", 42, true, "extra"])).toThrow();
 });
 
+test("tuple fills defaults for missing trailing elements", () => {
+  // Issue #5229: trailing `.default()`/`.prefault()` elements should be
+  // filled in when the input array is shorter than the tuple.
+  const t = z.tuple([z.string(), z.string().default("bravo")]);
+  expectTypeOf<typeof t._output>().toEqualTypeOf<[string, string]>();
+  expectTypeOf<typeof t._input>().toEqualTypeOf<[string, (string | undefined)?]>();
+
+  expect(t.parse(["alpha", "charlie"])).toEqual(["alpha", "charlie"]);
+  expect(t.parse(["alpha"])).toEqual(["alpha", "bravo"]);
+
+  // Multiple trailing defaults
+  const multi = z.tuple([z.string(), z.number().default(42), z.boolean().default(true)]);
+  expect(multi.parse(["hello"])).toEqual(["hello", 42, true]);
+  expect(multi.parse(["hello", 100])).toEqual(["hello", 100, true]);
+  expect(multi.parse(["hello", 100, false])).toEqual(["hello", 100, false]);
+
+  // Prefault parity
+  expect(z.tuple([z.string(), z.string().prefault("delta")]).parse(["alpha"])).toEqual(["alpha", "delta"]);
+
+  // Defaults wrapped in modifiers: `optout` propagates through these, so the
+  // fix is not type-name specific.
+  expect(z.tuple([z.string(), z.string().default("x").nullable()]).parse(["alpha"])).toEqual(["alpha", "x"]);
+  expect(z.tuple([z.string(), z.string().default("x").readonly()]).parse(["alpha"])).toEqual(["alpha", "x"]);
+  expect(z.tuple([z.string(), z.string().default("x").catch("y")]).parse(["alpha"])).toEqual(["alpha", "x"]);
+  expect(z.tuple([z.string(), z.string().default("x").pipe(z.string())]).parse(["alpha"])).toEqual(["alpha", "x"]);
+});
+
+test("tuple fills defaults under async parse", async () => {
+  const t = z.tuple([z.string(), z.string().default("zulu")]);
+  await expect(t.parseAsync(["alpha"])).resolves.toEqual(["alpha", "zulu"]);
+});
+
+test("tuple keeps length-1 array for missing `.optional()` elements", () => {
+  // Backwards compat: a trailing `.optional()` element that is omitted from
+  // the input must NOT be filled with `undefined` — the result stays length-1.
+  // Only schemas that produce a defined value get materialized.
+  const t = z.tuple([z.string(), z.string().optional()]);
+  const out = t.parse(["alpha"]);
+  expect(out).toEqual(["alpha"]);
+  expect(out.length).toEqual(1);
+
+  // `z.undefined()` is NOT a synonym for `.optional()` — its value type is
+  // *must be undefined*, so the slot is required input. Omitting it triggers
+  // a single `too_small` (no element-level errors, matching v3's abort
+  // semantics); passing explicit `undefined` succeeds and is preserved.
+  expect(z.tuple([z.string(), z.undefined()]).safeParse(["alpha"]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+  expect(z.tuple([z.string(), z.undefined()]).parse(["alpha", undefined])).toHaveLength(2);
+
+  // `.optional().nullable()` still trims — `.optional()` propagates the
+  // optin/optout flags through the nullable wrapper.
+  expect(z.tuple([z.string(), z.string().optional().nullable()]).parse(["alpha"])).toHaveLength(1);
+
+  // Multiple trailing optionals trim the same way — we don't fill the tail
+  // with literal `undefined`s.
+  const many = z.tuple([z.string(), z.string().optional(), z.string().optional(), z.string().optional()]);
+  expect(many.parse(["alpha"])).toEqual(["alpha"]);
+  expect(many.parse(["alpha", "beta"])).toEqual(["alpha", "beta"]);
+
+  // Explicit `undefined` inside `input.length` IS preserved — only slots
+  // past the input get trimmed.
+  const r = many.parse(["alpha", undefined]);
+  expect(r.length).toEqual(2);
+  expect(1 in r).toEqual(true);
+
+  // Trailing optionals after a default that fires are still trimmed.
+  expect(
+    z.tuple([z.string(), z.string().default("d"), z.string().optional(), z.string().optional()]).parse(["alpha"])
+  ).toEqual(["alpha", "d"]);
+});
+
+test("tuple result is dense when optional precedes a default", () => {
+  // `.optional()` before a `.default()` must produce an explicit `undefined`
+  // (not a sparse hole), otherwise `1 in r`, `JSON.stringify`, `Object.keys`,
+  // and iteration all behave wrong.
+  const t = z.tuple([z.string(), z.string().optional(), z.string().default("z")]);
+  const r = t.parse(["alpha"]);
+  expect(r).toEqual(["alpha", undefined, "z"]);
+  expect(r.length).toEqual(3);
+  expect(1 in r).toEqual(true);
+  expect(JSON.stringify(r)).toEqual('["alpha",null,"z"]');
+
+  // Trailing optional after a default is still dropped (no later default
+  // forces it to materialize).
+  expect(z.tuple([z.string(), z.string().default("d"), z.string().optional()]).parse(["alpha"])).toEqual([
+    "alpha",
+    "d",
+  ]);
+
+  // Multiple interleaved optional/default — every slot up to the last
+  // default must be present and dense.
+  const interleaved = z.tuple([
+    z.string(),
+    z.string().optional(),
+    z.string().default("d"),
+    z.string().optional(),
+    z.string().default("e"),
+  ]);
+  const out = interleaved.parse(["alpha"]);
+  expect(out).toEqual(["alpha", undefined, "d", undefined, "e"]);
+  expect(1 in out && 3 in out).toEqual(true);
+});
+
+test("tuple truncates absent optional rejections only when the output tail is optional", () => {
+  // An absent optional-output slot can only be swallowed when every later
+  // output slot is optional too. If a later default would make the output tail
+  // required, truncating would violate the tuple's output type.
+  const refusesUndefined = z
+    .string()
+    .optional()
+    .refine((s) => s !== undefined, "must not be undefined");
+
+  const trailingDefault = z.tuple([z.string(), refusesUndefined, z.string().default("d")]);
+  const r1 = trailingDefault.safeParse(["alpha"]);
+  expect(r1.success).toBe(false);
+  expect(r1.error!.issues[0].path).toEqual([1]);
+
+  // Optional slots BEFORE the rejected one still cannot hide a later required
+  // output slot.
+  const beforeReject = z.tuple([z.string(), z.string().optional(), refusesUndefined, z.string().default("d")]);
+  const r2 = beforeReject.safeParse(["alpha"]);
+  expect(r2.success).toBe(false);
+  expect(r2.error!.issues[0].path).toEqual([2]);
+
+  // No default after — truncate still applies, no spurious issue surfaces.
+  const noTrailingDefault = z.tuple([z.string(), refusesUndefined]);
+  const r3 = noTrailingDefault.safeParse(["alpha"]);
+  expect(r3.success).toBe(true);
+  expect(r3.data).toEqual(["alpha"]);
+});
+
+test("tuple rejects absent optional before required output under async parse", async () => {
+  const refusesUndefined = z
+    .string()
+    .optional()
+    .refine(async (s) => s !== undefined, "must not be undefined");
+
+  const schema = z.tuple([z.string(), refusesUndefined, z.string().default("d")]);
+  const r = await schema.safeParseAsync(["alpha"]);
+  expect(r.success).toBe(false);
+  expect(r.error!.issues[0].path).toEqual([1]);
+});
+
+test("tuple rejects absent exact optional before defaulted output", () => {
+  const schema = z.tuple([z.string(), z.string().exactOptional(), z.string().default("fallback")]);
+  expectTypeOf<typeof schema._output>().toEqualTypeOf<[string, string, string]>();
+
+  const missingExact = schema.safeParse(["alpha"]);
+  expect(missingExact.success).toBe(false);
+  expect(missingExact.error!.issues[0].path).toEqual([1]);
+
+  expect(schema.parse(["alpha", "bravo"])).toEqual(["alpha", "bravo", "fallback"]);
+  expect(schema.safeParse(["alpha", undefined]).success).toBe(false);
+
+  // With no later required output slot, exact optional still behaves like an
+  // omitted tuple tail and truncates cleanly.
+  expect(z.tuple([z.string(), z.string().exactOptional(), z.string().optional()]).parse(["alpha"])).toEqual(["alpha"]);
+});
+
+test("tuple preserves explicit undefined inside input even for optional-out schemas", () => {
+  // The trim only runs for slots PAST `input.length`. An explicit `undefined`
+  // value supplied by the caller at index < input.length must survive, even
+  // when the schema produces undefined as a valid output (e.g.
+  // `z.string().or(z.undefined())`, `z.string().optional()`, `z.undefined()`).
+  const orUndefined = z.tuple([z.string(), z.string().or(z.undefined())]);
+  const r1 = orUndefined.parse(["alpha", undefined]);
+  expect(r1.length).toEqual(2);
+  expect(r1[1]).toBeUndefined();
+  expect(1 in r1).toEqual(true);
+  expect(JSON.stringify(r1)).toEqual('["alpha",null]');
+
+  // Same for `.optional()`.
+  const opt = z.tuple([z.string(), z.string().optional()]);
+  const r2 = opt.parse(["alpha", undefined]);
+  expect(r2.length).toEqual(2);
+  expect(1 in r2).toEqual(true);
+
+  // Same for `z.undefined()` literal.
+  const lit = z.tuple([z.string(), z.undefined()]);
+  const r3 = lit.parse(["alpha", undefined]);
+  expect(r3.length).toEqual(2);
+  expect(1 in r3).toEqual(true);
+
+  // Mid-tuple explicit undefined surrounded by defined values is also kept.
+  const mid = z.tuple([z.string(), z.string().or(z.undefined()), z.string()]);
+  const r4 = mid.parse(["alpha", undefined, "gamma"]);
+  expect(r4).toEqual(["alpha", undefined, "gamma"]);
+  expect(r4.length).toEqual(3);
+  expect(1 in r4).toEqual(true);
+});
+
+test("tuple does NOT break when a required slot fails past input length", () => {
+  // A required slot (no `.optional()` chain, so optout !== "optional") past
+  // input length must still surface an issue rather than silently swallowing
+  // it. Otherwise we'd accept arbitrarily short tuples for required-tail
+  // schemas. The precheck collapses this into a single `too_small`.
+  const schema = z.tuple([z.string(), z.string()]);
+  expect(schema.safeParse(["alpha"]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+});
+
 test("tuple with rest schema", () => {
   const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
   expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
@@ -181,3 +406,91 @@ test("sparse array input", () => {
   const schema = z.tuple([z.string(), z.number()]);
   expect(() => schema.parse(new Array(2))).toThrow();
 });
+
+test("under-length tuple emits a single too_small with optStart minimum", () => {
+  const allRequired = z.tuple([z.string(), z.string()]);
+  expect(allRequired.safeParse(["a"]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+  expect(allRequired.safeParse([]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=2 items",
+        "minimum": 2,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+
+  const trailingOptional = z.tuple([z.string(), z.number().optional()]);
+  expect(trailingOptional.safeParse([]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=1 items",
+        "minimum": 1,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+
+  const interiorOptional = z.tuple([z.string(), z.number().optional(), z.string()]);
+  expect(interiorOptional.safeParse(["a", 1]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected array to have >=3 items",
+        "minimum": 3,
+        "origin": "array",
+        "path": [],
+      },
+    ]
+  `);
+});
+
+test("too_big tuple still surfaces element-wise type errors for present indices", () => {
+  const schema = z.tuple([z.string(), z.number()]);
+  expect(schema.safeParse([1, "x", "extra"]).error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "inclusive": true,
+        "maximum": 2,
+        "message": "Too big: expected array to have <=2 items",
+        "origin": "array",
+        "path": [],
+      },
+      {
+        "code": "invalid_type",
+        "expected": "string",
+        "message": "Invalid input: expected string, received number",
+        "path": [
+          0,
+        ],
+      },
+      {
+        "code": "invalid_type",
+        "expected": "number",
+        "message": "Invalid input: expected number, received string",
+        "path": [
+          1,
+        ],
+      },
+    ]
+  `);
+});

package/node_modules/@relaycast/sdk/node_modules/zod/src/v4/classic/tests/union.test.ts

@@ -217,3 +217,57 @@ test("z.xor() type inference", () => {
   type Result = z.infer<typeof schema>;
   expectTypeOf<Result>().toEqualTypeOf<string | number | boolean>();
 });
+
+test("z.union([]) constructs and rejects all input", () => {
+  const schema = z.union([]);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<never>();
+  const result = schema.safeParse("anything");
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_union",
+          "errors": [],
+          "message": "Invalid input",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});
+
+test("z.xor([]) constructs and rejects all input", () => {
+  const schema = z.xor([]);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<never>();
+  const result = schema.safeParse("anything");
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_union",
+          "errors": [],
+          "message": "Invalid input",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});
+
+test("z.discriminatedUnion with empty options constructs and rejects", () => {
+  const schema = z.discriminatedUnion("type", [] as any);
+  const nonObject = schema.safeParse("nope");
+  expect(nonObject.success).toEqual(false);
+  if (!nonObject.success) {
+    expect(nonObject.error.issues[0].code).toBe("invalid_type");
+  }
+  const obj = schema.safeParse({ type: "x" });
+  expect(obj.success).toEqual(false);
+  if (!obj.success) {
+    expect(obj.error.issues[0].code).toBe("invalid_union");
+    expect((obj.error.issues[0] as any).errors).toEqual([]);
+    expect((obj.error.issues[0] as any).options).toEqual([]);
+  }
+});