@shuttl-io/core 0.2.0

package/node_modules/zod/src/v4/core/tests/locales/he.test.ts

@@ -0,0 +1,379 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import he from "../../../locales/he.js";
+
+describe("Hebrew localization", () => {
+  beforeEach(() => {
+    z.config(he());
+  });
+
+  describe("too_small errors with definite article and gendered verbs", () => {
+    test("string type (feminine - צריכה)", () => {
+      const schema = z.string().min(3);
+      const result = schema.safeParse("ab");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קצר מדי: המחרוזת צריכה להכיל 3 תווים או יותר");
+      }
+    });
+
+    test("number type (masculine - צריך)", () => {
+      const schema = z.number().min(10);
+      const result = schema.safeParse(5);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
+      }
+    });
+
+    test("array type (masculine - צריך)", () => {
+      const schema = z.array(z.string()).min(1);
+      const result = schema.safeParse([]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המערך צריך להכיל לפחות פריט אחד");
+      }
+    });
+
+    test("set type (feminine - צריכה)", () => {
+      const schema = z.set(z.string()).min(2);
+      const result = schema.safeParse(new Set(["a"]));
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: הקבוצה (Set) צריכה להכיל 2 פריטים או יותר");
+      }
+    });
+  });
+
+  describe("too_big errors with definite article and gendered verbs", () => {
+    test("string type (feminine - צריכה)", () => {
+      const schema = z.string().max(3);
+      const result = schema.safeParse("abcde");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("ארוך מדי: המחרוזת צריכה להכיל 3 תווים או פחות");
+      }
+    });
+
+    test("number type (masculine - צריך)", () => {
+      const schema = z.number().max(365);
+      const result = schema.safeParse(400);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-365");
+      }
+    });
+
+    test("array max", () => {
+      const schema = z.array(z.string()).max(2);
+      const result = schema.safeParse(["a", "b", "c"]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המערך צריך להכיל 2 פריטים או פחות");
+      }
+    });
+  });
+
+  describe("invalid_type errors with definite article and gendered verbs", () => {
+    test("string expected (feminine), number received", () => {
+      const schema = z.string();
+      const result = schema.safeParse(123);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מחרוזת, התקבל מספר");
+      }
+    });
+
+    test("number expected (masculine), string received", () => {
+      const schema = z.number();
+      const result = schema.safeParse("abc");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
+      }
+    });
+
+    test("boolean expected (masculine), null received", () => {
+      const schema = z.boolean();
+      const result = schema.safeParse(null);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות ערך בוליאני, התקבל ערך ריק (null)");
+      }
+    });
+
+    test("array expected (masculine), object received", () => {
+      const schema = z.array(z.string());
+      const result = schema.safeParse({});
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מערך, התקבל אובייקט");
+      }
+    });
+
+    test("object expected (masculine), array received", () => {
+      const schema = z.object({ a: z.string() });
+      const result = schema.safeParse([]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות אובייקט, התקבל מערך");
+      }
+    });
+
+    test("function expected (feminine), string received", () => {
+      const schema = z.function();
+      const result = schema.safeParse("not a function");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות פונקציה, התקבל מחרוזת");
+      }
+    });
+  });
+
+  describe("gendered verbs consistency", () => {
+    test("feminine types use צריכה", () => {
+      const feminineTypes = [
+        { schema: z.string().min(5), input: "abc" },
+        { schema: z.set(z.string()).min(2), input: new Set(["a"]) },
+      ];
+
+      for (const { schema, input } of feminineTypes) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain("צריכה");
+        }
+      }
+    });
+
+    test("masculine types use צריך", () => {
+      const masculineTypes = [
+        { schema: z.number().min(10), input: 5 },
+        { schema: z.array(z.string()).min(2), input: ["a"] },
+      ];
+
+      for (const { schema, input } of masculineTypes) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain("צריך");
+        }
+      }
+    });
+  });
+
+  describe("invalid_value with enum", () => {
+    test("single value", () => {
+      const schema = z.enum(["a"]);
+      const result = schema.safeParse("b");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: הערך חייב להיות "a"');
+      }
+    });
+
+    test("two values", () => {
+      const schema = z.enum(["a", "b"]);
+      const result = schema.safeParse("c");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a" או "b"');
+      }
+    });
+
+    test("multiple values", () => {
+      const schema = z.enum(["a", "b", "c"]);
+      const result = schema.safeParse("d");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('ערך לא תקין: האפשרויות המתאימות הן "a", "b" או "c"');
+      }
+    });
+  });
+
+  describe("other error types", () => {
+    test("not_multiple_of", () => {
+      const schema = z.number().multipleOf(3);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("מספר לא תקין: חייב להיות מכפלה של 3");
+      }
+    });
+
+    test("unrecognized_keys - single key", () => {
+      const schema = z.object({ a: z.string() }).strict();
+      const result = schema.safeParse({ a: "test", b: "extra" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('מפתח לא מזוהה: "b"');
+      }
+    });
+
+    test("unrecognized_keys - multiple keys", () => {
+      const schema = z.object({ a: z.string() }).strict();
+      const result = schema.safeParse({ a: "test", b: "extra", c: "more" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('מפתחות לא מזוהים: "b", "c"');
+      }
+    });
+
+    test("invalid_union", () => {
+      const schema = z.union([z.string(), z.number()]);
+      const result = schema.safeParse(true);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין");
+      }
+    });
+
+    test("invalid_key in object", () => {
+      const schema = z.record(z.number(), z.string());
+      const result = schema.safeParse({ notANumber: "value" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("שדה לא תקין באובייקט");
+      }
+    });
+  });
+
+  describe("invalid_format with string checks", () => {
+    test("startsWith", () => {
+      const schema = z.string().startsWith("hello");
+      const result = schema.safeParse("world");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להתחיל ב "hello"');
+      }
+    });
+
+    test("endsWith", () => {
+      const schema = z.string().endsWith("world");
+      const result = schema.safeParse("hello");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת להסתיים ב "world"');
+      }
+    });
+
+    test("includes", () => {
+      const schema = z.string().includes("test");
+      const result = schema.safeParse("hello world");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe('המחרוזת חייבת לכלול "test"');
+      }
+    });
+
+    test("regex", () => {
+      const schema = z.string().regex(/^[a-z]+$/);
+      const result = schema.safeParse("ABC123");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("המחרוזת חייבת להתאים לתבנית /^[a-z]+$/");
+      }
+    });
+  });
+
+  describe("invalid_format with common formats", () => {
+    test("email", () => {
+      const schema = z.string().email();
+      const result = schema.safeParse("not-an-email");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("כתובת אימייל לא תקינה");
+      }
+    });
+
+    test("url", () => {
+      const schema = z.string().url();
+      const result = schema.safeParse("not-a-url");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("כתובת רשת לא תקינה");
+      }
+    });
+
+    test("uuid", () => {
+      const schema = z.string().uuid();
+      const result = schema.safeParse("not-a-uuid");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("UUID לא תקין");
+      }
+    });
+  });
+
+  describe("tuple validation", () => {
+    test("invalid element type in tuple shows full error message", () => {
+      const schema = z.tuple([z.string(), z.number()]);
+      const result = schema.safeParse(["abc", "not a number"]);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קלט לא תקין: צריך להיות מספר, התקבל מחרוזת");
+      }
+    });
+  });
+
+  describe("inclusive vs exclusive bounds", () => {
+    test("inclusive minimum (>=)", () => {
+      const schema = z.number().min(10);
+      const result = schema.safeParse(5);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול או שווה ל-10");
+      }
+    });
+
+    test("exclusive minimum (>)", () => {
+      const schema = z.number().gt(10);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("קטן מדי: המספר צריך להיות גדול מ-10");
+      }
+    });
+
+    test("inclusive maximum (<=)", () => {
+      const schema = z.number().max(10);
+      const result = schema.safeParse(15);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן או שווה ל-10");
+      }
+    });
+
+    test("exclusive maximum (<)", () => {
+      const schema = z.number().lt(10);
+      const result = schema.safeParse(10);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toBe("גדול מדי: המספר צריך להיות קטן מ-10");
+      }
+    });
+  });
+
+  describe("all type names with definite article", () => {
+    test("verifies all type translations are correct", () => {
+      const types = [
+        { schema: z.string(), expected: "מחרוזת", input: 123 },
+        { schema: z.number(), expected: "מספר", input: "abc" },
+        { schema: z.boolean(), expected: "ערך בוליאני", input: "abc" },
+        { schema: z.bigint(), expected: "BigInt", input: "abc" },
+        { schema: z.date(), expected: "תאריך", input: "abc" },
+        { schema: z.array(z.any()), expected: "מערך", input: "abc" },
+        { schema: z.object({}), expected: "אובייקט", input: "abc" },
+        { schema: z.function(), expected: "פונקציה", input: "abc" },
+      ];
+
+      for (const { schema, expected, input } of types) {
+        const result = schema.safeParse(input);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error.issues[0].message).toContain(expected);
+        }
+      }
+    });
+  });
+});

package/node_modules/zod/src/v4/core/tests/locales/nl.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "vitest";
+import nl from "../../../locales/nl.js";
+
+test("Dutch locale error messages", () => {
+  const { localeError } = nl();
+
+  // Test invalid_type
+  expect(
+    localeError({
+      code: "invalid_type",
+      expected: "string",
+      input: 123,
+    })
+  ).toBe("Ongeldige invoer: verwacht string, ontving getal");
+
+  // Test too_big with sizing
+  expect(
+    localeError({
+      code: "too_big",
+      origin: "string",
+      maximum: 10,
+      inclusive: true,
+      input: "test string that is too long",
+    })
+  ).toBe("Te groot: verwacht dat string te hebben <=10 tekens");
+
+  // Test too_small with sizing
+  expect(
+    localeError({
+      code: "too_small",
+      origin: "array",
+      minimum: 5,
+      inclusive: false,
+      input: [1, 2],
+    })
+  ).toBe("Te klein: verwacht dat array te hebben >5 elementen");
+
+  // Test invalid_format
+  expect(
+    localeError({
+      code: "invalid_format",
+      format: "email",
+      input: "invalid-email",
+    })
+  ).toBe("Ongeldig: emailadres");
+});

package/node_modules/zod/src/v4/core/tests/locales/ru.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from "vitest";
+import ru from "../../../locales/ru.js";
+
+describe("Russian localization", () => {
+  const localeError = ru().localeError;
+
+  describe("pluralization rules", () => {
+    for (const { type, cases } of TEST_CASES) {
+      describe(`${type} pluralization`, () => {
+        for (const { count, expected } of cases) {
+          it(`correctly pluralizes ${count} ${type}`, () => {
+            const error = localeError({
+              code: "too_small",
+              minimum: count,
+              type: "number",
+              inclusive: true,
+              path: [],
+              origin: type,
+              input: count - 1,
+            });
+
+            expect(error).toContain(expected);
+          });
+        }
+      });
+    }
+
+    it("handles negative numbers correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: -2,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -3,
+      });
+
+      expect(error).toContain("-2 элемента");
+    });
+
+    it("handles zero correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: 0,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -1,
+      });
+
+      expect(error).toContain("0 элементов");
+    });
+
+    it("handles bigint values correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: BigInt(21),
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: BigInt(20),
+      });
+
+      expect(error).toContain("21 элемент");
+    });
+  });
+});
+
+const TEST_CASES = [
+  {
+    type: "array",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элемента" },
+      { count: 5, expected: "5 элементов" },
+      { count: 11, expected: "11 элементов" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элемента" },
+      { count: 25, expected: "25 элементов" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементов" },
+    ],
+  },
+  {
+    type: "set",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элемента" },
+      { count: 5, expected: "5 элементов" },
+      { count: 11, expected: "11 элементов" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элемента" },
+      { count: 25, expected: "25 элементов" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементов" },
+    ],
+  },
+  {
+    type: "string",
+    cases: [
+      { count: 1, expected: "1 символ" },
+      { count: 2, expected: "2 символа" },
+      { count: 5, expected: "5 символов" },
+      { count: 11, expected: "11 символов" },
+      { count: 21, expected: "21 символ" },
+      { count: 22, expected: "22 символа" },
+      { count: 25, expected: "25 символов" },
+    ],
+  },
+  {
+    type: "file",
+    cases: [
+      { count: 0, expected: "0 байт" },
+      { count: 1, expected: "1 байт" },
+      { count: 2, expected: "2 байта" },
+      { count: 5, expected: "5 байт" },
+      { count: 11, expected: "11 байт" },
+      { count: 21, expected: "21 байт" },
+      { count: 22, expected: "22 байта" },
+      { count: 25, expected: "25 байт" },
+      { count: 101, expected: "101 байт" },
+      { count: 110, expected: "110 байт" },
+    ],
+  },
+] as const;

package/node_modules/zod/src/v4/core/tests/locales/tr.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+import { parsedType } from "../../../locales/tr.js";
+
+test("parsedType", () => {
+  expect(parsedType("string")).toBe("string");
+  expect(parsedType(1)).toBe("number");
+  expect(parsedType(true)).toBe("boolean");
+  expect(parsedType(null)).toBe("null");
+  expect(parsedType(undefined)).toBe("undefined");
+  expect(parsedType([])).toBe("array");
+  expect(parsedType({})).toBe("object");
+  expect(parsedType(new Date())).toBe("Date");
+  expect(parsedType(new Map())).toBe("Map");
+  expect(parsedType(new Set())).toBe("Set");
+  expect(parsedType(new Error())).toBe("Error");
+
+  const nullPrototype = Object.create(null);
+  expect(parsedType(nullPrototype)).toBe("object");
+
+  const doubleNullPrototype = Object.create(Object.create(null));
+  expect(parsedType(doubleNullPrototype)).toBe("object");
+
+  expect(parsedType(Number.NaN)).toBe("NaN");
+});
+
+test("locales - tr", () => {
+  z.config(z.locales.tr());
+
+  const invalidType = z.number().safeParse("a");
+  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType.error!.issues[0].message).toBe("Geçersiz değer: beklenen number, alınan string");
+
+  const invalidType2 = z.string().safeParse(1);
+  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType2.error!.issues[0].message).toBe("Geçersiz değer: beklenen string, alınan number");
+
+  const invalidValue = z.enum(["a", "b"]).safeParse(1);
+  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
+  expect(invalidValue.error!.issues[0].message).toBe('Geçersiz seçenek: aşağıdakilerden biri olmalı: "a"|"b"');
+
+  const tooBig = z.number().max(10).safeParse(15);
+  expect(tooBig.error!.issues[0].code).toBe("too_big");
+  expect(tooBig.error!.issues[0].message).toBe("Çok büyük: beklenen number <=10");
+
+  const tooSmall = z.number().min(10).safeParse(5);
+  expect(tooSmall.error!.issues[0].code).toBe("too_small");
+  expect(tooSmall.error!.issues[0].message).toBe("Çok küçük: beklenen number >=10");
+
+  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
+  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatRegex.error!.issues[0].message).toBe("Geçersiz metin: /abcd/ desenine uymalı");
+
+  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
+  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatStartsWith.error!.issues[0].message).toBe('Geçersiz metin: "abcd" ile başlamalı');
+
+  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
+  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
+  expect(notMultipleOf.error!.issues[0].message).toBe("Geçersiz sayı: 3 ile tam bölünebilmeli");
+
+  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
+  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
+  expect(unrecognizedKeys.error!.issues[0].message).toBe('Tanınmayan anahtar: "c"');
+
+  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
+  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
+  expect(invalidUnion.error!.issues[0].message).toBe("Geçersiz değer");
+});

package/node_modules/zod/src/v4/core/tests/record-constructor.test.ts

@@ -0,0 +1,67 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("record should parse objects with non-function constructor field", () => {
+  const schema = z.record(z.string(), z.any());
+
+  expect(() => schema.parse({ constructor: "string", key: "value" })).not.toThrow();
+
+  const result1 = schema.parse({ constructor: "string", key: "value" });
+  expect(result1).toEqual({ constructor: "string", key: "value" });
+
+  expect(() => schema.parse({ constructor: 123, key: "value" })).not.toThrow();
+
+  const result2 = schema.parse({ constructor: 123, key: "value" });
+  expect(result2).toEqual({ constructor: 123, key: "value" });
+
+  expect(() => schema.parse({ constructor: null, key: "value" })).not.toThrow();
+
+  const result3 = schema.parse({ constructor: null, key: "value" });
+  expect(result3).toEqual({ constructor: null, key: "value" });
+
+  expect(() => schema.parse({ constructor: {}, key: "value" })).not.toThrow();
+
+  const result4 = schema.parse({ constructor: {}, key: "value" });
+  expect(result4).toEqual({ constructor: {}, key: "value" });
+
+  expect(() => schema.parse({ constructor: [], key: "value" })).not.toThrow();
+
+  const result5 = schema.parse({ constructor: [], key: "value" });
+  expect(result5).toEqual({ constructor: [], key: "value" });
+
+  expect(() => schema.parse({ constructor: true, key: "value" })).not.toThrow();
+
+  const result6 = schema.parse({ constructor: true, key: "value" });
+  expect(result6).toEqual({ constructor: true, key: "value" });
+});
+
+test("record should still work with normal objects", () => {
+  const schema = z.record(z.string(), z.string());
+
+  expect(() => schema.parse({ normalKey: "value" })).not.toThrow();
+
+  const result1 = schema.parse({ normalKey: "value" });
+  expect(result1).toEqual({ normalKey: "value" });
+
+  expect(() => schema.parse({ key1: "value1", key2: "value2" })).not.toThrow();
+
+  const result2 = schema.parse({ key1: "value1", key2: "value2" });
+  expect(result2).toEqual({ key1: "value1", key2: "value2" });
+});
+
+test("record should validate values according to schema even with constructor field", () => {
+  const stringSchema = z.record(z.string(), z.string());
+
+  expect(() => stringSchema.parse({ constructor: "string", key: "value" })).not.toThrow();
+
+  expect(() => stringSchema.parse({ constructor: 123, key: "value" })).toThrow();
+});
+
+test("record should work with different key types and constructor field", () => {
+  const enumSchema = z.record(z.enum(["constructor", "key"]), z.string());
+
+  expect(() => enumSchema.parse({ constructor: "value1", key: "value2" })).not.toThrow();
+
+  const result = enumSchema.parse({ constructor: "value1", key: "value2" });
+  expect(result).toEqual({ constructor: "value1", key: "value2" });
+});