fullstacked 0.12.0-1272 → 0.12.0-1290

package/fullstacked_modules/zod/src/v4/classic/tests/literal.test.ts

@@ -90,28 +90,3 @@ test("readonly", () => {
   const a = ["asdf"] as const;
   z.literal(a);
 });
-
-test("literal pattern", () => {
-  expect(z.literal(1.1)._zod.pattern).toMatchInlineSnapshot(`/\\^\\(1\\\\\\.1\\)\\$/`);
-
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1.1")).toMatchInlineSnapshot(`
-    {
-      "data": "1.1",
-      "success": true,
-    }
-  `);
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1n1")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_format",
-        "format": "template_literal",
-        "pattern": "^(1\\\\.1)$",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/number.test.ts

@@ -114,29 +114,6 @@ test(".nonnegative() validation", () => {
   expect(() => schema.parse(-1)).toThrow();
 });
 
-test("multipleOf", () => {
-  const numbers = {
-    number3: 5.123,
-    number6: 5.123456,
-    number7: 5.1234567,
-    number8: 5.12345678,
-  };
-
-  const schemas = {
-    schema6: z.number().multipleOf(0.000001),
-    schema7: z.number().multipleOf(0.0000001),
-  };
-
-  expect(() => schemas.schema6.parse(numbers.number3)).not.toThrow();
-  expect(() => schemas.schema6.parse(numbers.number6)).not.toThrow();
-  expect(() => schemas.schema6.parse(numbers.number7)).toThrow();
-  expect(() => schemas.schema6.parse(numbers.number8)).toThrow();
-  expect(() => schemas.schema7.parse(numbers.number3)).not.toThrow();
-  expect(() => schemas.schema7.parse(numbers.number6)).not.toThrow();
-  expect(() => schemas.schema7.parse(numbers.number7)).not.toThrow();
-  expect(() => schemas.schema7.parse(numbers.number8)).toThrow();
-});
-
 test(".multipleOf() with positive divisor", () => {
   const schema = z.number().multipleOf(5);
   expect(schema.parse(15)).toEqual(15);

package/fullstacked_modules/zod/src/v4/classic/tests/optional.test.ts

@@ -121,16 +121,3 @@ test("pipe optionality inside objects", () => {
     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 });
-});

package/fullstacked_modules/zod/src/v4/classic/tests/partial.test.ts

@@ -145,196 +145,3 @@ test("partial with mask -- ignore falsy values", async () => {
   masked.parse({ country: "US" });
   await masked.parseAsync({ country: "US" });
 });
-
-test("catch/prefault/default", () => {
-  const mySchema = z.object({
-    a: z.string().catch("catch value").optional(),
-    b: z.string().default("default value").optional(),
-    c: z.string().prefault("prefault value").optional(),
-    d: z.string().catch("catch value"),
-    e: z.string().default("default value"),
-    f: z.string().prefault("prefault value"),
-  });
-
-  expect(mySchema.parse({})).toMatchInlineSnapshot(`
-    {
-      "b": "default value",
-      "c": "prefault value",
-      "d": "catch value",
-      "e": "default value",
-      "f": "prefault value",
-    }
-  `);
-
-  expect(mySchema.parse({}, { jitless: true })).toMatchInlineSnapshot(`
-    {
-      "b": "default value",
-      "c": "prefault value",
-      "d": "catch value",
-      "e": "default value",
-      "f": "prefault value",
-    }
-  `);
-});
-
-test("handleOptionalObjectResult branches", () => {
-  const mySchema = z.object({
-    // Branch: input[key] === undefined, key not in input, caught error
-    caughtMissing: z.string().catch("caught").optional(),
-    // Branch: input[key] === undefined, key in input, caught error
-    caughtUndefined: z.string().catch("caught").optional(),
-    // Branch: input[key] === undefined, key not in input, validation issues
-    issueMissing: z.string().min(5).optional(),
-    // Branch: input[key] === undefined, key in input, validation issues
-    issueUndefined: z.string().min(5).optional(),
-    // Branch: input[key] === undefined, validation returns undefined
-    validUndefined: z.string().optional(),
-    // Branch: input[key] === undefined, non-undefined result (default/transform)
-    defaultValue: z.string().default("default").optional(),
-    // Branch: input[key] defined, caught error
-    caughtDefined: z.string().catch("caught").optional(),
-    // Branch: input[key] defined, validation issues
-    issueDefined: z.string().min(5).optional(),
-    // Branch: input[key] defined, validation returns undefined
-    validDefinedUndefined: z
-      .string()
-      .transform(() => undefined)
-      .optional(),
-    // Branch: input[key] defined, non-undefined value
-    validDefined: z.string().optional(),
-  });
-
-  // Test input[key] === undefined cases
-  const result1 = mySchema.parse(
-    {
-      // caughtMissing: not present (key not in input)
-      caughtUndefined: undefined, // key in input
-      // issueMissing: not present (key not in input)
-      issueUndefined: undefined, // key in input
-      validUndefined: undefined,
-      // defaultValue: not present, will get default
-    },
-    { jitless: true }
-  );
-
-  expect(result1).toEqual({
-    caughtUndefined: undefined,
-    issueUndefined: undefined,
-    validUndefined: undefined,
-    defaultValue: "default",
-  });
-
-  // Test input[key] defined cases (successful)
-  const result2 = mySchema.parse(
-    {
-      caughtDefined: 123, // invalid type, should catch
-      validDefinedUndefined: "test", // transforms to undefined
-      validDefined: "valid", // valid value
-    },
-    { jitless: true }
-  );
-
-  expect(result2).toEqual({
-    caughtDefined: "caught",
-    validDefinedUndefined: undefined,
-    validDefined: "valid",
-    defaultValue: "default",
-  });
-
-  // Test validation issues are properly reported (input[key] defined, validation fails)
-  expect(() =>
-    mySchema.parse(
-      {
-        issueDefined: "abc", // too short
-      },
-      { jitless: true }
-    )
-  ).toThrow();
-});
-
-test("fastpass vs non-fastpass consistency", () => {
-  const mySchema = z.object({
-    caughtMissing: z.string().catch("caught").optional(),
-    caughtUndefined: z.string().catch("caught").optional(),
-    issueMissing: z.string().min(5).optional(),
-    issueUndefined: z.string().min(5).optional(),
-    validUndefined: z.string().optional(),
-    defaultValue: z.string().default("default").optional(),
-    caughtDefined: z.string().catch("caught").optional(),
-    validDefinedUndefined: z
-      .string()
-      .transform(() => undefined)
-      .optional(),
-    validDefined: z.string().optional(),
-  });
-
-  const input = {
-    caughtUndefined: undefined,
-    issueUndefined: undefined,
-    validUndefined: undefined,
-    caughtDefined: 123,
-    validDefinedUndefined: "test",
-    validDefined: "valid",
-  };
-
-  // Test both paths produce identical results
-  const jitlessResult = mySchema.parse(input, { jitless: true });
-  const fastpassResult = mySchema.parse(input);
-
-  expect(jitlessResult).toEqual(fastpassResult);
-  expect(jitlessResult).toEqual({
-    caughtUndefined: undefined,
-    issueUndefined: undefined,
-    validUndefined: undefined,
-    defaultValue: "default",
-    caughtDefined: "caught",
-    validDefinedUndefined: undefined,
-    validDefined: "valid",
-  });
-});
-
-test("optional with check", () => {
-  const baseSchema = z
-    .string()
-    .optional()
-    .check(({ value, ...ctx }) => {
-      ctx.issues.push({
-        code: "custom",
-        input: value,
-        message: "message",
-      });
-    });
-
-  // this correctly fails
-  expect(baseSchema.safeParse(undefined)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "message",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  const schemaObject = z.object({
-    date: baseSchema,
-  });
-
-  expect(schemaObject.safeParse({ date: undefined })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "message",
-        "path": [
-          "date"
-        ]
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/pickomit.test.ts

@@ -114,14 +114,14 @@ test("pick/omit/required/partial - do not allow unknown keys", () => {
     age: z.number(),
   });
 
-  expect(() => schema.pick({ name: true, asdf: true }).safeParse({})).toThrow();
+  expect(() => schema.pick({ name: true, asdf: true })).toThrow();
 
   // @ts-expect-error
-  expect(() => schema.pick({ $unknown: true }).safeParse({})).toThrow();
+  expect(() => schema.pick({ $unknown: true })).toThrow();
   // @ts-expect-error
-  expect(() => schema.omit({ $unknown: true }).safeParse({})).toThrow();
+  expect(() => schema.omit({ $unknown: true })).toThrow();
   // @ts-expect-error
-  expect(() => schema.required({ $unknown: true }).safeParse({})).toThrow();
+  expect(() => schema.required({ $unknown: true })).toThrow();
   // @ts-expect-error
-  expect(() => schema.partial({ $unknown: true }).safeParse({})).toThrow();
+  expect(() => schema.partial({ $unknown: true })).toThrow();
 });

package/fullstacked_modules/zod/src/v4/classic/tests/preprocess.test.ts

@@ -73,18 +73,17 @@ test("preprocess ctx.addIssue with parse", () => {
   `);
 });
 
-test("preprocess ctx.addIssue fatal by default", () => {
+test("preprocess ctx.addIssue non-fatal by default", () => {
   const schema = z.preprocess((data, ctx) => {
     ctx.addIssue({
       code: "custom",
       message: `custom error`,
     });
-
     return data;
   }, z.string());
   const result = schema.safeParse(1234);
 
-  expect(result.error!.issues).toHaveLength(1);
+  expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
       "error": [ZodError: [
@@ -92,6 +91,12 @@ test("preprocess ctx.addIssue fatal by default", () => {
         "code": "custom",
         "message": "custom error",
         "path": []
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
       }
     ]],
       "success": false,
@@ -170,7 +175,7 @@ test("z.NEVER in preprocess", () => {
   expectTypeOf<foo>().toEqualTypeOf<number>();
   const result = foo.safeParse(undefined);
 
-  expect(result.error!.issues).toHaveLength(1);
+  expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
       "error": [ZodError: [
@@ -178,6 +183,12 @@ test("z.NEVER in preprocess", () => {
         "code": "custom",
         "message": "bad",
         "path": []
+      },
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected number, received object"
       }
     ]],
       "success": false,

package/fullstacked_modules/zod/src/v4/classic/tests/record.test.ts

@@ -336,21 +336,7 @@ test("partial record", () => {
   type schema = z.infer<typeof schema>;
   expectTypeOf<schema>().toEqualTypeOf<Partial<Record<string, string>>>();
 
-  const Keys = z.enum(["id", "name", "email"]); //.or(z.never());
+  const Keys = z.enum(["id", "name", "email"]).or(z.never());
   const Person = z.partialRecord(Keys, z.string());
   expectTypeOf<z.infer<typeof Person>>().toEqualTypeOf<Partial<Record<"id" | "name" | "email", string>>>();
-
-  Person.parse({
-    id: "123",
-    // name: "John",
-    // email: "john@example.com",
-  });
-
-  Person.parse({
-    // id: "123",
-    // name: "John",
-    email: "john@example.com",
-  });
-
-  expect(Person.def.keyType._zod.def.type).toEqual("enum");
 });

package/fullstacked_modules/zod/src/v4/classic/tests/recursive-types.test.ts

@@ -260,127 +260,6 @@ test("mutual recursion with meta", () => {
   expectTypeOf<B>().toEqualTypeOf<_B>();
 });
 
-test("intersection with recursive types", () => {
-  const A = z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("CONTAINER"),
-    }),
-    z.object({
-      type: z.literal("SCREEN"),
-      config: z.object({ x: z.number(), y: z.number() }),
-    }),
-  ]);
-  // type A = z.infer<typeof A>;
-
-  const B = z.object({
-    get children() {
-      return z.array(C).optional();
-    },
-  });
-  // type B = z.infer<typeof B>;
-
-  const C = z.intersection(A, B);
-  type C = z.infer<typeof C>;
-
-  type _C = (
-    | {
-        type: "CONTAINER";
-      }
-    | {
-        type: "SCREEN";
-        config: {
-          x: number;
-          y: number;
-        };
-      }
-  ) & {
-    children?: _C[] | undefined;
-  };
-  expectTypeOf<C>().toEqualTypeOf<_C>();
-});
-
-test("object utilities with recursive types", () => {
-  const NodeBase = z.object({
-    id: z.string(),
-    name: z.string(),
-    get children() {
-      return z.array(Node).optional();
-    },
-  });
-
-  // Test extend
-  const NodeOne = NodeBase.extend({
-    name: z.literal("nodeOne"),
-    get children() {
-      return z.array(Node);
-    },
-  });
-
-  const NodeTwo = NodeBase.extend({
-    name: z.literal("nodeTwo"),
-    get children() {
-      return z.array(Node);
-    },
-  });
-
-  // Test pick
-  const PickedNode = NodeBase.pick({ id: true, name: true });
-
-  // Test omit
-  const OmittedNode = NodeBase.omit({ children: true });
-
-  // Test merge
-  const ExtraProps = {
-    metadata: z.string(),
-    get parent() {
-      return Node.optional();
-    },
-  };
-  const MergedNode = NodeBase.extend(ExtraProps);
-
-  // Test partial
-  const PartialNode = NodeBase.partial();
-  const PartialMaskedNode = NodeBase.partial({ name: true });
-
-  // Test required (assuming NodeBase has optional fields)
-  const OptionalNodeBase = z.object({
-    id: z.string().optional(),
-    name: z.string().optional(),
-    get children() {
-      return z.array(Node).optional();
-    },
-  });
-  const RequiredNode = OptionalNodeBase.required();
-  const RequiredMaskedNode = OptionalNodeBase.required({ id: true });
-
-  const Node = z.union([
-    NodeOne,
-    NodeTwo,
-    PickedNode,
-    OmittedNode,
-    MergedNode,
-    PartialNode,
-    PartialMaskedNode,
-    RequiredNode,
-    RequiredMaskedNode,
-  ]);
-});
-
-test("tuple with recursive types", () => {
-  const TaskListNodeSchema = z.strictObject({
-    type: z.literal("taskList"),
-    get content() {
-      return z.array(z.tuple([TaskListNodeSchema, z.union([TaskListNodeSchema])])).min(1);
-    },
-  });
-  type TaskListNodeSchema = z.infer<typeof TaskListNodeSchema>;
-  type _TaskListNodeSchema = {
-    type: "taskList";
-    content: [_TaskListNodeSchema, _TaskListNodeSchema][];
-  };
-  expectTypeOf<TaskListNodeSchema>().toEqualTypeOf<_TaskListNodeSchema>();
-});
-
 test("recursion compatibility", () => {
   // array
   const A = z.object({

package/fullstacked_modules/zod/src/v4/classic/tests/string.test.ts

@@ -318,83 +318,6 @@ test("url validations", () => {
   expect(() => url.parse("https://")).toThrow();
 });
 
-test("url preserves original input", () => {
-  const url = z.string().url();
-
-  // Test the specific case from the user report
-  const input = "https://example.com?key=NUXOmHqWNVTapJkJJHw8BfD155AuqhH_qju_5fNmQ4ZHV7u8";
-  const output = url.parse(input);
-  expect(output).toBe(input); // Should preserve the original input exactly
-
-  // Test other cases where URL constructor would normalize
-  expect(url.parse("https://example.com?foo=bar")).toBe("https://example.com?foo=bar");
-  expect(url.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
-  expect(url.parse("https://sub.example.com?param=value&other=data")).toBe(
-    "https://sub.example.com?param=value&other=data"
-  );
-
-  // Test cases with trailing slashes are preserved
-  expect(url.parse("https://example.com/")).toBe("https://example.com/");
-  expect(url.parse("https://example.com/path/")).toBe("https://example.com/path/");
-
-  // Test cases with paths and query parameters
-  expect(url.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
-});
-
-test("url trims whitespace", () => {
-  const url = z.string().url();
-
-  // Test trimming whitespace from URLs
-  expect(url.parse("  https://example.com  ")).toBe("https://example.com");
-  expect(url.parse("  https://example.com/path?query=param  ")).toBe("https://example.com/path?query=param");
-  expect(url.parse("\t\nhttps://example.com\t\n")).toBe("https://example.com");
-  expect(url.parse("   https://example.com?key=value   ")).toBe("https://example.com?key=value");
-
-  // Test that URLs without extra whitespace are unchanged
-  expect(url.parse("https://example.com")).toBe("https://example.com");
-  expect(url.parse("https://example.com/path")).toBe("https://example.com/path");
-});
-
-test("url normalize flag", () => {
-  const normalizeUrl = z.url({ normalize: true });
-  const preserveUrl = z.url(); // normalize: false/undefined by default
-
-  // Test that normalize flag causes URL normalization
-  expect(normalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
-  expect(normalizeUrl.parse("http://example.com?test=123")).toBe("http://example.com/?test=123");
-
-  // Test with already normalized URLs
-  expect(normalizeUrl.parse("https://example.com/")).toBe("https://example.com/");
-  expect(normalizeUrl.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
-
-  // Test complex URLs with normalization
-  expect(normalizeUrl.parse("https://example.com/../?key=value")).toBe("https://example.com/?key=value");
-  expect(normalizeUrl.parse("https://example.com/./path?key=value")).toBe("https://example.com/path?key=value");
-
-  // Compare with non-normalize behavior
-  expect(preserveUrl.parse("https://example.com?key=value")).toBe("https://example.com?key=value");
-  expect(preserveUrl.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
-
-  // Test trimming with normalize
-  expect(normalizeUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com/?key=value");
-  expect(preserveUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com?key=value");
-});
-
-test("url normalize with hostname and protocol constraints", () => {
-  const constrainedNormalizeUrl = z.url({
-    normalize: true,
-    protocol: /^https$/,
-    hostname: /^example\.com$/,
-  });
-
-  // Test that normalization works with constraints
-  expect(constrainedNormalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
-
-  // Test that constraints are still enforced
-  expect(() => constrainedNormalizeUrl.parse("http://example.com?key=value")).toThrow();
-  expect(() => constrainedNormalizeUrl.parse("https://other.com?key=value")).toThrow();
-});
-
 test("httpurl", () => {
   const httpUrl = z.url({
     protocol: /^https?$/,
@@ -541,8 +464,8 @@ test(`bad uuid`, () => {
     "9491d710-3185-0e06-bea0-6a2f275345e0",
     "9491d710-3185-5e06-0ea0-6a2f275345e0",
     "d89e7b01-7598-ed11-9d7a-0022489382fd", // new sequential id
-    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
-    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
+    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
+    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
     "invalid uuid",
     "9491d710-3185-4e06-bea0-6a2f275345e0X",
     "ffffffff-ffff-ffff-ffff-ffffffffffff",
@@ -558,8 +481,8 @@ test("good guid", () => {
   for (const goodGuid of [
     "9491d710-3185-4e06-bea0-6a2f275345e0",
     "d89e7b01-7598-ed11-9d7a-0022489382fd", // new sequential id
-    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
-    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
+    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
+    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
     "00000000-0000-0000-0000-000000000000",
     "ffffffff-ffff-ffff-ffff-ffffffffffff",
   ]) {
@@ -956,41 +879,3 @@ test("E.164 validation", () => {
   expect(validE164Numbers.every((number) => e164Number.safeParse(number).success)).toBe(true);
   expect(invalidE164Numbers.every((number) => e164Number.safeParse(number).success === false)).toBe(true);
 });
-
-test("hostname", () => {
-  const hostname = z.hostname();
-
-  // Valid hostnames
-  hostname.parse("localhost");
-  hostname.parse("example.com");
-  hostname.parse("sub.example.com");
-  hostname.parse("a-b-c.example.com");
-  hostname.parse("123.example.com");
-  hostname.parse("example-123.com");
-  hostname.parse("example-123.1234");
-  hostname.parse("developer.mozilla.org");
-  hostname.parse("hello.world.example.com");
-  hostname.parse("www.google.com");
-  hostname.parse("192.168.1.1");
-  hostname.parse("xn--d1acj3b.com");
-  hostname.parse("xn--d1acj3b.org");
-  hostname.parse("xn--d1acj3b");
-
-  // Invalid hostnames
-  expect(() => hostname.parse("")).toThrow();
-  expect(() => hostname.parse("example..com")).toThrow();
-  expect(() => hostname.parse("example-.com")).toThrow();
-  expect(() => hostname.parse("-example.com")).toThrow();
-  expect(() => hostname.parse("example.com-")).toThrow();
-  expect(() => hostname.parse("example_com")).toThrow();
-  expect(() => hostname.parse("example.com:8080")).toThrow();
-  expect(() => hostname.parse("http://example.com")).toThrow();
-  expect(() => hostname.parse("ht!tp://invalid.com")).toThrow();
-
-  expect(() => hostname.parse("xn--d1acj3b..com")).toThrow();
-  expect(() => hostname.parse("ex@mple.com")).toThrow();
-  expect(() => hostname.parse("[2001:db8::zzzz]")).toThrow();
-  expect(() => hostname.parse("exa mple.com")).toThrow();
-  expect(() => hostname.parse("-example.com")).toThrow();
-  expect(() => hostname.parse("example..com")).toThrow();
-});

package/fullstacked_modules/zod/src/v4/classic/tests/template-literal.test.ts

@@ -6,7 +6,6 @@ const hello = z.templateLiteral(["hello"]);
 const world = z.templateLiteral(["", z.literal("world")]);
 const one = z.templateLiteral([1]);
 const two = z.templateLiteral(["", z.literal(2)]);
-const onePointOne = z.templateLiteral([z.literal(1.1)]);
 const truee = z.templateLiteral([true]);
 const anotherTrue = z.templateLiteral(["", z.literal(true)]);
 const falsee = z.templateLiteral([false]);
@@ -290,7 +289,6 @@ test("template literal parsing - success - basic cases", () => {
   world.parse("world");
   one.parse("1");
   two.parse("2");
-  onePointOne.parse("1.1");
   truee.parse("true");
   anotherTrue.parse("true");
   falsee.parse("false");
@@ -383,7 +381,6 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => one.parse("2")).toThrow();
   expect(() => one.parse("12")).toThrow();
   expect(() => one.parse("21")).toThrow();
-  expect(() => onePointOne.parse("1s1")).toThrow();
   expect(() => two.parse("1")).toThrow();
   expect(() => two.parse("21")).toThrow();
   expect(() => two.parse("12")).toThrow();