@guru-ai-product/ai-product-kit 0.2.251117213210 → 0.2.251118120602

package/mcp/node_modules/zod/src/v3/tests/catch.test.ts

@@ -1,220 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import { z } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("basic catch", () => {
-  expect(z.string().catch("default").parse(undefined)).toBe("default");
-});
-
-test("catch fn does not run when parsing succeeds", () => {
-  let isCalled = false;
-  const cb = () => {
-    isCalled = true;
-    return "asdf";
-  };
-  expect(z.string().catch(cb).parse("test")).toBe("test");
-  expect(isCalled).toEqual(false);
-});
-
-test("basic catch async", async () => {
-  const result = await z.string().catch("default").parseAsync(1243);
-  expect(result).toBe("default");
-});
-
-test("catch replace wrong types", () => {
-  expect(z.string().catch("default").parse(true)).toBe("default");
-  expect(z.string().catch("default").parse(true)).toBe("default");
-  expect(z.string().catch("default").parse(15)).toBe("default");
-  expect(z.string().catch("default").parse([])).toBe("default");
-  expect(z.string().catch("default").parse(new Map())).toBe("default");
-  expect(z.string().catch("default").parse(new Set())).toBe("default");
-  expect(z.string().catch("default").parse({})).toBe("default");
-});
-
-test("catch with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .catch("default");
-  expect(stringWithDefault.parse(undefined)).toBe("default");
-  expect(stringWithDefault.parse(15)).toBe("default");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
-  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, unknown>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("catch on existing optional", () => {
-  const stringWithDefault = z.string().optional().catch("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe(undefined);
-  expect(stringWithDefault.parse(15)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, unknown>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string | undefined>(true);
-});
-
-test("optional on catch", () => {
-  const stringWithDefault = z.string().catch("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, unknown>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string | undefined>(true);
-});
-
-test("complex chain example", () => {
-  const complex = z
-    .string()
-    .catch("asdf")
-    .transform((val) => val + "!")
-    .transform((val) => val.toUpperCase())
-    .catch("qwer")
-    .removeCatch()
-    .optional()
-    .catch("asdfasdf");
-
-  expect(complex.parse("qwer")).toBe("QWER!");
-  expect(complex.parse(15)).toBe("ASDF!");
-  expect(complex.parse(true)).toBe("ASDF!");
-});
-
-test("removeCatch", () => {
-  const stringWithRemovedDefault = z.string().catch("asdf").removeCatch();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("nested", () => {
-  const inner = z.string().catch("asdf");
-  const outer = z.object({ inner }).catch({
-    inner: "asdf",
-  });
-  type input = z.input<typeof outer>;
-  util.assertEqual<input, unknown>(true);
-  type out = z.output<typeof outer>;
-  util.assertEqual<out, { inner: string }>(true);
-  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained catch", () => {
-  const stringWithDefault = z.string().catch("inner").catch("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("inner");
-  const resultDiff = stringWithDefault.parse(5);
-  expect(resultDiff).toEqual("inner");
-});
-
-test("factory", () => {
-  z.ZodCatch.create(z.string(), {
-    catch: "asdf",
-  }).parse(undefined);
-});
-
-test("native enum", () => {
-  enum Fruits {
-    apple = "apple",
-    orange = "orange",
-  }
-
-  const schema = z.object({
-    fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
-  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
-});
-
-test("enum", () => {
-  const schema = z.object({
-    fruit: z.enum(["apple", "orange"]).catch("apple"),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: "apple" });
-  expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
-  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
-});
-
-test("reported issues with nested usage", () => {
-  const schema = z.object({
-    string: z.string(),
-    obj: z.object({
-      sub: z.object({
-        lit: z.literal("a"),
-        subCatch: z.number().catch(23),
-      }),
-      midCatch: z.number().catch(42),
-    }),
-    number: z.number().catch(0),
-    bool: z.boolean(),
-  });
-
-  try {
-    schema.parse({
-      string: {},
-      obj: {
-        sub: {
-          lit: "b",
-          subCatch: "24",
-        },
-        midCatch: 444,
-      },
-      number: "",
-      bool: "yes",
-    });
-  } catch (error) {
-    const issues = (error as z.ZodError).issues;
-
-    expect(issues.length).toEqual(3);
-    expect(issues[0].message).toMatch("string");
-    expect(issues[1].message).toMatch("literal");
-    expect(issues[2].message).toMatch("boolean");
-  }
-});
-
-test("catch error", () => {
-  let catchError: z.ZodError | undefined = undefined;
-
-  const schema = z.object({
-    age: z.number(),
-    name: z.string().catch((ctx) => {
-      catchError = ctx.error;
-
-      return "John Doe";
-    }),
-  });
-
-  const result = schema.safeParse({
-    age: null,
-    name: null,
-  });
-
-  expect(result.success).toEqual(false);
-  expect(!result.success && result.error.issues.length).toEqual(1);
-  expect(!result.success && result.error.issues[0].message).toMatch("number");
-
-  expect(catchError).toBeInstanceOf(z.ZodError);
-  expect(catchError !== undefined && (catchError as z.ZodError).issues.length).toEqual(1);
-  expect(catchError !== undefined && (catchError as z.ZodError).issues[0].message).toMatch("string");
-});
-
-test("ctx.input", () => {
-  const schema = z.string().catch((ctx) => {
-    return String(ctx.input);
-  });
-
-  expect(schema.parse(123)).toEqual("123");
-});

package/mcp/node_modules/zod/src/v3/tests/coerce.test.ts

@@ -1,133 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("string coercion", () => {
-  const schema = z.coerce.string();
-  expect(schema.parse("sup")).toEqual("sup");
-  expect(schema.parse("")).toEqual("");
-  expect(schema.parse(12)).toEqual("12");
-  expect(schema.parse(0)).toEqual("0");
-  expect(schema.parse(-12)).toEqual("-12");
-  expect(schema.parse(3.14)).toEqual("3.14");
-  expect(schema.parse(BigInt(15))).toEqual("15");
-  expect(schema.parse(Number.NaN)).toEqual("NaN");
-  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual("Infinity");
-  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual("-Infinity");
-  expect(schema.parse(true)).toEqual("true");
-  expect(schema.parse(false)).toEqual("false");
-  expect(schema.parse(null)).toEqual("null");
-  expect(schema.parse(undefined)).toEqual("undefined");
-  expect(schema.parse({ hello: "world!" })).toEqual("[object Object]");
-  expect(schema.parse(["item", "another_item"])).toEqual("item,another_item");
-  expect(schema.parse([])).toEqual("");
-  expect(schema.parse(new Date("2022-01-01T00:00:00.000Z"))).toEqual(new Date("2022-01-01T00:00:00.000Z").toString());
-});
-
-test("number coercion", () => {
-  const schema = z.coerce.number();
-  expect(schema.parse("12")).toEqual(12);
-  expect(schema.parse("0")).toEqual(0);
-  expect(schema.parse("-12")).toEqual(-12);
-  expect(schema.parse("3.14")).toEqual(3.14);
-  expect(schema.parse("")).toEqual(0);
-  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // z.ZodError
-  expect(schema.parse(12)).toEqual(12);
-  expect(schema.parse(0)).toEqual(0);
-  expect(schema.parse(-12)).toEqual(-12);
-  expect(schema.parse(3.14)).toEqual(3.14);
-  expect(schema.parse(BigInt(15))).toEqual(15);
-  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
-  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(Number.POSITIVE_INFINITY);
-  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(Number.NEGATIVE_INFINITY);
-  expect(schema.parse(true)).toEqual(1);
-  expect(schema.parse(false)).toEqual(0);
-  expect(schema.parse(null)).toEqual(0);
-  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
-  expect(schema.parse([])).toEqual(0);
-  expect(schema.parse(new Date(1670139203496))).toEqual(1670139203496);
-});
-
-test("boolean coercion", () => {
-  const schema = z.coerce.boolean();
-  expect(schema.parse("true")).toEqual(true);
-  expect(schema.parse("false")).toEqual(true);
-  expect(schema.parse("0")).toEqual(true);
-  expect(schema.parse("1")).toEqual(true);
-  expect(schema.parse("")).toEqual(false);
-  expect(schema.parse(1)).toEqual(true);
-  expect(schema.parse(0)).toEqual(false);
-  expect(schema.parse(-1)).toEqual(true);
-  expect(schema.parse(3.14)).toEqual(true);
-  expect(schema.parse(BigInt(15))).toEqual(true);
-  expect(schema.parse(Number.NaN)).toEqual(false);
-  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(true);
-  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(true);
-  expect(schema.parse(true)).toEqual(true);
-  expect(schema.parse(false)).toEqual(false);
-  expect(schema.parse(null)).toEqual(false);
-  expect(schema.parse(undefined)).toEqual(false);
-  expect(schema.parse({ hello: "world!" })).toEqual(true);
-  expect(schema.parse(["item", "another_item"])).toEqual(true);
-  expect(schema.parse([])).toEqual(true);
-  expect(schema.parse(new Date(1670139203496))).toEqual(true);
-});
-
-test("bigint coercion", () => {
-  const schema = z.coerce.bigint();
-  expect(schema.parse("5")).toEqual(BigInt(5));
-  expect(schema.parse("0")).toEqual(BigInt(0));
-  expect(schema.parse("-5")).toEqual(BigInt(-5));
-  expect(() => schema.parse("3.14")).toThrow(); // not a z.ZodError!
-  expect(schema.parse("")).toEqual(BigInt(0));
-  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // not a z.ZodError!
-  expect(schema.parse(5)).toEqual(BigInt(5));
-  expect(schema.parse(0)).toEqual(BigInt(0));
-  expect(schema.parse(-5)).toEqual(BigInt(-5));
-  expect(() => schema.parse(3.14)).toThrow(); // not a z.ZodError!
-  expect(schema.parse(BigInt(5))).toEqual(BigInt(5));
-  expect(() => schema.parse(Number.NaN)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // not a z.ZodError!
-  expect(schema.parse(true)).toEqual(BigInt(1));
-  expect(schema.parse(false)).toEqual(BigInt(0));
-  expect(() => schema.parse(null)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(undefined)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // not a z.ZodError!
-  expect(schema.parse([])).toEqual(BigInt(0));
-  expect(schema.parse(new Date(1670139203496))).toEqual(BigInt(1670139203496));
-});
-
-test("date coercion", () => {
-  const schema = z.coerce.date();
-  expect(schema.parse(new Date().toDateString())).toBeInstanceOf(Date);
-  expect(schema.parse(new Date().toISOString())).toBeInstanceOf(Date);
-  expect(schema.parse(new Date().toUTCString())).toBeInstanceOf(Date);
-  expect(schema.parse("5")).toBeInstanceOf(Date);
-  expect(schema.parse("2000-01-01")).toBeInstanceOf(Date);
-  // expect(schema.parse("0")).toBeInstanceOf(Date);
-  // expect(schema.parse("-5")).toBeInstanceOf(Date);
-  // expect(schema.parse("3.14")).toBeInstanceOf(Date);
-  expect(() => schema.parse("")).toThrow(); // z.ZodError
-  expect(() => schema.parse("NOT_A_DATE")).toThrow(); // z.ZodError
-  expect(schema.parse(5)).toBeInstanceOf(Date);
-  expect(schema.parse(0)).toBeInstanceOf(Date);
-  expect(schema.parse(-5)).toBeInstanceOf(Date);
-  expect(schema.parse(3.14)).toBeInstanceOf(Date);
-  expect(() => schema.parse(BigInt(5))).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
-  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // z.ZodError
-  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // z.ZodError
-  expect(schema.parse(true)).toBeInstanceOf(Date);
-  expect(schema.parse(false)).toBeInstanceOf(Date);
-  expect(schema.parse(null)).toBeInstanceOf(Date);
-  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
-  expect(() => schema.parse([])).toThrow(); // z.ZodError
-  expect(schema.parse(new Date())).toBeInstanceOf(Date);
-});

package/mcp/node_modules/zod/src/v3/tests/complex.test.ts

@@ -1,56 +0,0 @@
-import { test } from "vitest";
-import * as z from "zod/v3";
-
-const crazySchema = z.object({
-  tuple: z.tuple([
-    z.string().nullable().optional(),
-    z.number().nullable().optional(),
-    z.boolean().nullable().optional(),
-    z.null().nullable().optional(),
-    z.undefined().nullable().optional(),
-    z.literal("1234").nullable().optional(),
-  ]),
-  merged: z
-    .object({
-      k1: z.string().optional(),
-    })
-    .merge(z.object({ k1: z.string().nullable(), k2: z.number() })),
-  union: z.array(z.union([z.literal("asdf"), z.literal(12)])).nonempty(),
-  array: z.array(z.number()),
-  // sumTransformer: z.transformer(z.array(z.number()), z.number(), (arg) => {
-  //   return arg.reduce((a, b) => a + b, 0);
-  // }),
-  sumMinLength: z.array(z.number()).refine((arg) => arg.length > 5),
-  intersection: z.intersection(z.object({ p1: z.string().optional() }), z.object({ p1: z.number().optional() })),
-  enum: z.intersection(z.enum(["zero", "one"]), z.enum(["one", "two"])),
-  nonstrict: z.object({ points: z.number() }).nonstrict(),
-  numProm: z.promise(z.number()),
-  lenfun: z.function(z.tuple([z.string()]), z.boolean()),
-});
-
-// const asyncCrazySchema = crazySchema.extend({
-//   // async_transform: z.transformer(
-//   //   z.array(z.number()),
-//   //   z.number(),
-//   //   async (arg) => {
-//   //     return arg.reduce((a, b) => a + b, 0);
-//   //   }
-//   // ),
-//   async_refine: z.array(z.number()).refine(async (arg) => arg.length > 5),
-// });
-
-test("parse", () => {
-  crazySchema.parse({
-    tuple: ["asdf", 1234, true, null, undefined, "1234"],
-    merged: { k1: "asdf", k2: 12 },
-    union: ["asdf", 12, "asdf", 12, "asdf", 12],
-    array: [12, 15, 16],
-    // sumTransformer: [12, 15, 16],
-    sumMinLength: [12, 15, 16, 98, 24, 63],
-    intersection: {},
-    enum: "one",
-    nonstrict: { points: 1234 },
-    numProm: Promise.resolve(12),
-    lenfun: (x: string) => x.length,
-  });
-});

package/mcp/node_modules/zod/src/v3/tests/custom.test.ts

@@ -1,31 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("passing validations", () => {
-  const example1 = z.custom<number>((x) => typeof x === "number");
-  example1.parse(1234);
-  expect(() => example1.parse({})).toThrow();
-});
-
-test("string params", () => {
-  const example1 = z.custom<number>((x) => typeof x !== "number", "customerr");
-  const result = example1.safeParse(1234);
-  expect(result.success).toEqual(false);
-  // @ts-ignore
-  expect(JSON.stringify(result.error).includes("customerr")).toEqual(true);
-});
-
-test("async validations", async () => {
-  const example1 = z.custom<number>(async (x) => {
-    return typeof x === "number";
-  });
-  const r1 = await example1.safeParseAsync(1234);
-  expect(r1.success).toEqual(true);
-  expect(r1.data).toEqual(1234);
-
-  const r2 = await example1.safeParseAsync("asdf");
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues.length).toEqual(1);
-});

package/mcp/node_modules/zod/src/v3/tests/date.test.ts

@@ -1,32 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const beforeBenchmarkDate = new Date(2022, 10, 4);
-const benchmarkDate = new Date(2022, 10, 5);
-const afterBenchmarkDate = new Date(2022, 10, 6);
-
-const minCheck = z.date().min(benchmarkDate);
-const maxCheck = z.date().max(benchmarkDate);
-
-test("passing validations", () => {
-  minCheck.parse(benchmarkDate);
-  minCheck.parse(afterBenchmarkDate);
-
-  maxCheck.parse(benchmarkDate);
-  maxCheck.parse(beforeBenchmarkDate);
-});
-
-test("failing validations", () => {
-  expect(() => minCheck.parse(beforeBenchmarkDate)).toThrow();
-  expect(() => maxCheck.parse(afterBenchmarkDate)).toThrow();
-});
-
-test("min max getters", () => {
-  expect(minCheck.minDate).toEqual(benchmarkDate);
-  expect(minCheck.min(afterBenchmarkDate).minDate).toEqual(afterBenchmarkDate);
-
-  expect(maxCheck.maxDate).toEqual(benchmarkDate);
-  expect(maxCheck.max(beforeBenchmarkDate).maxDate).toEqual(beforeBenchmarkDate);
-});

package/mcp/node_modules/zod/src/v3/tests/deepmasking.test.ts

@@ -1,186 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("test", () => {
-  z;
-});
-
-// const fish = z.object({
-//   name: z.string(),
-//   props: z.object({
-//     color: z.string(),
-//     numScales: z.number(),
-//   }),
-// });
-
-// const nonStrict = z
-//   .object({
-//     name: z.string(),
-//     color: z.string(),
-//   })
-//   .nonstrict();
-
-// test('object pick type', () => {
-//   const modNonStrictFish = nonStrict.omit({ name: true });
-//   modNonStrictFish.parse({ color: 'asdf' });
-
-//   const bad1 = () => fish.pick({ props: { unknown: true } } as any);
-//   const bad2 = () => fish.omit({ name: true, props: { unknown: true } } as any);
-
-//   expect(bad1).toThrow();
-//   expect(bad2).toThrow();
-// });
-
-// test('f1', () => {
-//   const f1 = fish.pick(true);
-//   f1.parse({ name: 'a', props: { color: 'b', numScales: 3 } });
-// });
-// test('f2', () => {
-//   const f2 = fish.pick({ props: true });
-//   f2.parse({ props: { color: 'asdf', numScales: 1 } });
-//   const badcheck2 = () => f2.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck2).toThrow();
-// });
-// test('f3', () => {
-//   const f3 = fish.pick({ props: { color: true } });
-//   f3.parse({ props: { color: 'b' } });
-//   const badcheck3 = () => f3.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck3).toThrow();
-// });
-// test('f4', () => {
-//   const badcheck4 = () => fish.pick({ props: { color: true, unknown: true } });
-//   expect(badcheck4).toThrow();
-// });
-// test('f6', () => {
-//   const f6 = fish.omit({ props: true });
-//   const badcheck6 = () => f6.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   f6.parse({ name: 'adsf' });
-//   expect(badcheck6).toThrow();
-// });
-// test('f7', () => {
-//   const f7 = fish.omit({ props: { color: true } });
-//   f7.parse({ name: 'a', props: { numScales: 3 } });
-//   const badcheck7 = () => f7.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck7).toThrow();
-// });
-// test('f8', () => {
-//   const badcheck8 = () => fish.omit({ props: { color: true, unknown: true } });
-//   expect(badcheck8).toThrow();
-// });
-// test('f9', () => {
-//   const f9 = nonStrict.pick(true);
-//   f9.parse({ name: 'a', color: 'asdf' });
-// });
-// test('f10', () => {
-//   const f10 = nonStrict.pick({ name: true });
-//   f10.parse({ name: 'a' });
-//   const val = f10.parse({ name: 'a', color: 'b' });
-//   expect(val).toEqual({ name: 'a' });
-// });
-// test('f12', () => {
-//   const badfcheck12 = () => nonStrict.omit({ color: true, asdf: true });
-//   expect(badfcheck12).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const modFishArray = fishArray.pick({
-//     name: true,
-//     props: {
-//       numScales: true,
-//     },
-//   });
-
-//   modFishArray.parse([{ name: 'fish', props: { numScales: 12 } }]);
-//   const bad1 = () => modFishArray.parse([{ name: 'fish', props: { numScales: 12, color: 'asdf' } }] as any);
-//   expect(bad1).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const fail = () =>
-//     fishArray.pick({
-//       name: true,
-//       props: {
-//         whatever: true,
-//       },
-//     } as any);
-//   expect(fail).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const fail = () =>
-//     fishArray.omit({
-//       whateve: true,
-//     } as any);
-//   expect(fail).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const modFishList = fishArray.omit({
-//     name: true,
-//     props: {
-//       color: true,
-//     },
-//   });
-
-//   modFishList.parse([{ props: { numScales: 12 } }]);
-//   const fail = () => modFishList.parse([{ name: 'hello', props: { numScales: 12 } }] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('primitive array masking', () => {
-//   const fishArray = z.array(z.number());
-//   const fail = () => fishArray.pick({} as any);
-//   expect(fail).toThrow();
-// });
-
-// test('other array masking', () => {
-//   const fishArray = z.array(z.array(z.number()));
-//   const fail = () => fishArray.pick({} as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #1', () => {
-//   const fail = () => fish.pick(1 as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #2', () => {
-//   const fail = () => fish.pick([] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #3', () => {
-//   const fail = () => fish.pick(false as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #4', () => {
-//   const fail = () => fish.pick('asdf' as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #5', () => {
-//   const fail = () => fish.omit(1 as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #6', () => {
-//   const fail = () => fish.omit([] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #7', () => {
-//   const fail = () => fish.omit(false as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #8', () => {
-//   const fail = () => fish.omit('asdf' as any);
-//   expect(fail).toThrow();
-// });