@loomhelm/multi-task-flow 0.2.7 → 0.2.8

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

@@ -1,109 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
-
-test("z.number", () => {
-  const a = z.number();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-
-  type a = z.infer<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<number>();
-});
-
-test("z.number async", async () => {
-  const a = z.number().check(z.refine(async (_) => _ > 0));
-  await expect(z.parseAsync(a, 123)).resolves.toEqual(123);
-  await expect(() => z.parseAsync(a, -123)).rejects.toThrow();
-  await expect(() => z.parseAsync(a, "123")).rejects.toThrow();
-});
-
-test("z.int", () => {
-  const a = z.int();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-});
-
-test("z.float32", () => {
-  const a = z.float32();
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123.45")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  // -3.4028234663852886e38, 3.4028234663852886e38;
-  expect(() => z.parse(a, 3.4028234663852886e38 * 2)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -3.4028234663852886e38 * 2)).toThrow(); // Exceeds min
-});
-
-test("z.float64", () => {
-  const a = z.float64();
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123.45")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 1.7976931348623157e308 * 2)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -1.7976931348623157e308 * 2)).toThrow(); // Exceeds min
-});
-
-test("z.int32", () => {
-  const a = z.int32();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 2147483648)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -2147483649)).toThrow(); // Exceeds min
-});
-
-test("z.uint32", () => {
-  const a = z.uint32();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, -123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 4294967296)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -1)).toThrow(); // Below min
-});
-
-test("z.int64", () => {
-  const a = z.int64();
-  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow();
-  expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow();
-  // expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow(); // Exceeds max
-  // expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow(); // Exceeds min
-});
-
-test("z.uint64", () => {
-  const a = z.uint64();
-  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, -123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
-  expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
-  // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
-  // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
-});
-
-test("number and bigint formats are distinct at the type level", () => {
-  expectTypeOf(z.int()._zod.def.format).toEqualTypeOf<"safeint">();
-  expectTypeOf(z.uint32()._zod.def.format).toEqualTypeOf<"uint32">();
-  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
-
-  z.int32() satisfies z.ZodMiniInt32;
-  z.uint64() satisfies z.ZodMiniUInt64;
-
-  // @ts-expect-error a float64 schema is not a ZodMiniFloat32
-  z.float64() satisfies z.ZodMiniFloat32;
-  // @ts-expect-error a uint64 schema is not a ZodMiniInt64
-  z.uint64() satisfies z.ZodMiniInt64;
-});

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

@@ -1,292 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
-
-test("z.object", () => {
-  const a = z.object({
-    name: z.string(),
-    age: z.number(),
-    points: z.optional(z.number()),
-    "test?": z.boolean(),
-  });
-
-  a._zod.def.shape["test?"];
-  a._zod.def.shape.points._zod.optin;
-
-  type a = z.output<typeof a>;
-
-  expectTypeOf<a>().toEqualTypeOf<{
-    name: string;
-    age: number;
-    points?: number | undefined;
-    "test?": boolean;
-  }>();
-  expect(z.parse(a, { name: "john", age: 30, "test?": true })).toEqual({
-    name: "john",
-    age: 30,
-    "test?": true,
-  });
-  // "test?" is required in ZodObject
-  expect(() => z.parse(a, { name: "john", age: "30" })).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-
-  // null prototype
-  const schema = z.object({ a: z.string() });
-  const obj = Object.create(null);
-  obj.a = "foo";
-  expect(schema.parse(obj)).toEqual({ a: "foo" });
-});
-
-test("z.object().check()", () => {
-  const a = z.object({
-    name: z.string(),
-    age: z.number(),
-    points: z.optional(z.number()),
-    "test?": z.boolean(),
-  });
-
-  type a = z.output<typeof a>;
-
-  a.check(({ value }) => {
-    expectTypeOf(value).toEqualTypeOf<a>();
-  });
-});
-
-test("z.strictObject", () => {
-  const a = z.strictObject({
-    name: z.string(),
-  });
-  expect(z.parse(a, { name: "john" })).toEqual({ name: "john" });
-  expect(() => z.parse(a, { name: "john", age: 30 })).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-test("z.looseObject", () => {
-  const a = z.looseObject({
-    name: z.string(),
-    age: z.number(),
-  });
-  expect(z.parse(a, { name: "john", age: 30 })).toEqual({
-    name: "john",
-    age: 30,
-  });
-  expect(z.parse(a, { name: "john", age: 30, extra: true })).toEqual({
-    name: "john",
-    age: 30,
-    extra: true,
-  });
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-const userSchema = z.object({
-  name: z.string(),
-  age: z.number(),
-  email: z.optional(z.string()),
-});
-
-test("z.keyof", () => {
-  // z.keyof returns an enum schema of the keys of an object schema
-  const userKeysSchema = z.keyof(userSchema);
-  type UserKeys = z.infer<typeof userKeysSchema>;
-  expectTypeOf<UserKeys>().toEqualTypeOf<"name" | "age" | "email">();
-  expect(userKeysSchema).toBeDefined();
-  expect(userKeysSchema._zod.def.type).toBe("enum");
-  expect(userKeysSchema._zod.def.entries).toEqual({
-    name: "name",
-    age: "age",
-    email: "email",
-  });
-  expect(z.safeParse(userKeysSchema, "name").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "age").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "email").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "isAdmin").success).toBe(false);
-});
-
-test("z.extend", () => {
-  const extendedSchema = z.extend(userSchema, {
-    isAdmin: z.boolean(),
-  });
-  type ExtendedUser = z.infer<typeof extendedSchema>;
-  expectTypeOf<ExtendedUser>().toEqualTypeOf<{
-    name: string;
-    age: number;
-    email?: string | undefined;
-    isAdmin: boolean;
-  }>();
-  expect(extendedSchema).toBeDefined();
-  expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
-});
-
-test("z.merge", () => {
-  const mergedSchema = z.merge(userSchema, z.object({ isAdmin: z.boolean() }));
-  type MergedUser = z.infer<typeof mergedSchema>;
-  expectTypeOf<MergedUser>().toEqualTypeOf<{
-    name: string;
-    age: number;
-    email?: string | undefined;
-    isAdmin: boolean;
-  }>();
-  expect(z.safeParse(mergedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
-
-  // the second schema's catchall wins, matching classic
-  const strict = z.merge(userSchema, z.strictObject({ isAdmin: z.boolean() }));
-  expect(z.safeParse(strict, { name: "John", age: 30, isAdmin: true, extra: 1 }).success).toBe(false);
-
-  expect(() =>
-    // @ts-expect-error second argument is a schema, not a shape
-    z.merge(userSchema, { isAdmin: z.boolean() })
-  ).toThrow("Invalid input to merge");
-});
-
-test("z.safeExtend", () => {
-  const extended = z.safeExtend(userSchema, { name: z.string() });
-  expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
-  type Extended = z.infer<typeof extended>;
-  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string | undefined }>();
-  // @ts-expect-error
-  z.safeExtend(userSchema, { name: z.number() });
-});
-
-test("z.pick", () => {
-  const pickedSchema = z.pick(userSchema, { name: true, email: true });
-  type PickedUser = z.infer<typeof pickedSchema>;
-  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string | undefined }>();
-  expect(pickedSchema).toBeDefined();
-  expect(z.safeParse(pickedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
-});
-
-test("z.omit", () => {
-  const omittedSchema = z.omit(userSchema, { age: true });
-  type OmittedUser = z.infer<typeof omittedSchema>;
-  expectTypeOf<OmittedUser>().toEqualTypeOf<{
-    name: string;
-    email?: string | undefined;
-  }>();
-  expect(omittedSchema).toBeDefined();
-  expect(Reflect.ownKeys(omittedSchema._zod.def.shape)).toEqual(["name", "email"]);
-  expect(z.safeParse(omittedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
-});
-
-test("z.partial", () => {
-  const partialSchema = z.partial(userSchema);
-  type PartialUser = z.infer<typeof partialSchema>;
-  expectTypeOf<PartialUser>().toEqualTypeOf<{
-    name?: string | undefined;
-    age?: number | undefined;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
-});
-
-test("z.partial with mask", () => {
-  const partialSchemaWithMask = z.partial(userSchema, { name: true });
-  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
-  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
-    name?: string | undefined;
-    age: number;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
-  expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
-});
-
-test("z.exactPartial", () => {
-  const partialSchema = z.exactPartial(userSchema);
-  type PartialUser = z.infer<typeof partialSchema>;
-  expectTypeOf<PartialUser>().toEqualTypeOf<{
-    name?: string;
-    age?: number;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
-  expect(z.safeParse(partialSchema, {}).success).toBe(true);
-  expect(z.safeParse(partialSchema, { name: undefined }).success).toBe(false);
-  expect(z.safeParse(partialSchema, { email: undefined }).success).toBe(true);
-});
-
-test("z.exactPartial with mask", () => {
-  const partialSchemaWithMask = z.exactPartial(userSchema, { name: true });
-  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
-  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
-    name?: string;
-    age: number;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
-  expect(z.safeParse(partialSchemaWithMask, { age: 30, name: undefined }).success).toBe(false);
-});
-
-test("z.required", () => {
-  const requiredSchema = z.required(userSchema);
-  type RequiredUser = z.infer<typeof requiredSchema>;
-  expectTypeOf<RequiredUser>().toEqualTypeOf<{ name: string; age: number; email: string }>();
-  expect(requiredSchema.shape.email).toBeInstanceOf(z.ZodMiniNonOptional);
-  expect(z.safeParse(requiredSchema, { name: "John", age: 30 }).success).toBe(false);
-  expect(z.safeParse(requiredSchema, { name: "John", age: 30, email: "john@example.com" }).success).toBe(true);
-});
-
-test("z.required with mask", () => {
-  const schema = z.object({ name: z.optional(z.string()), age: z.optional(z.number()) });
-  const requiredSchemaWithMask = z.required(schema, { name: true });
-  type RequiredWithMask = z.infer<typeof requiredSchemaWithMask>;
-  expectTypeOf<RequiredWithMask>().toEqualTypeOf<{ name: string; age?: number | undefined }>();
-  expect(requiredSchemaWithMask.shape.name).toBeInstanceOf(z.ZodMiniNonOptional);
-  expect(requiredSchemaWithMask.shape.age).toBeInstanceOf(z.ZodMiniOptional);
-});
-
-test("z.pick/omit/partial/required - do not allow unknown keys", () => {
-  const schema = z.object({
-    name: z.string(),
-    age: z.number(),
-  });
-
-  // Mixed valid + invalid keys - throws at parse time (lazy evaluation)
-  // @ts-expect-error
-  expect(() => z.parse(z.pick(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.omit(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.partial(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.required(schema, { name: true, asdf: true }), {})).toThrow();
-
-  // Only invalid keys
-  // @ts-expect-error
-  expect(() => z.parse(z.pick(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.omit(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.partial(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.required(schema, { $unknown: true }), {})).toThrow();
-});
-
-test("z.catchall", () => {
-  // z.catchall()
-  const schema = z.catchall(
-    z.object({
-      name: z.string(),
-      // age: z.number(),
-    }),
-    z.string()
-  );
-
-  type schemaIn = z.input<typeof schema>;
-  type schemaOut = z.output<typeof schema>;
-  expectTypeOf<schemaIn>().toEqualTypeOf<{
-    name: string;
-    [key: string]: string;
-  }>();
-
-  expectTypeOf<schemaOut>().toEqualTypeOf<{
-    name: string;
-    [key: string]: string;
-  }>();
-
-  schema.parse({
-    name: "john",
-    age: "30",
-    extra: "extra value",
-  });
-
-  expect(() => schema.parse({ name: "john", age: 30 })).toThrow();
-});

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

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/mini";
-
-declare module "zod/v4/core" {
-  interface $ZodType {
-    /** @deprecated */
-    _core(): string;
-  }
-}
-
-test("prototype extension", () => {
-  z.core.$ZodType.prototype._core = function () {
-    return "_core";
-  };
-
-  // should pass
-  const result = z.string()._core();
-  expect(result).toBe("_core");
-  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
-
-  // clean up
-  z.ZodMiniType.prototype._core = undefined;
-});
-
-declare module "zod/v4/mini" {
-  interface ZodMiniType {
-    /** @deprecated */
-    _mini(): string;
-  }
-}
-
-test("prototype extension", () => {
-  z.ZodMiniType.prototype._mini = function () {
-    return "_mini";
-  };
-
-  // should pass
-  const result = z.string()._mini();
-  expect(result).toBe("_mini");
-
-  // clean up
-  z.ZodMiniType.prototype._mini = undefined;
-});