@loomhelm/multi-task-flow 0.2.6 → 0.2.8

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

@@ -1,57 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "../index.js";
-
-test("basic apply (number)", () => {
-  const setCommonNumberChecks = <T extends z.ZodMiniNumber>(schema: T) => {
-    return schema.check(z.minimum(0), z.maximum(100));
-  };
-
-  const schema = z.nullable(z.number().apply(setCommonNumberChecks));
-
-  expect(() => z.parse(schema, -1)).toThrowError();
-  expect(() => z.parse(schema, 101)).toThrowError();
-  expect(z.parse(schema, 0)).toBe(0);
-  expect(z.parse(schema, null)).toBe(null);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
-});
-
-test("The callback's return value becomes the apply's return value.", () => {
-  const symbol = Symbol();
-  const result = z.number().apply(() => symbol);
-
-  expect(result).toBe(symbol);
-  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
-});
-
-test("apply forwards extra args to the callback", () => {
-  const calls: unknown[] = [];
-  const capture = (schema: z.ZodMiniString, ...args: unknown[]) => {
-    calls.push(schema, ...args);
-    return schema;
-  };
-
-  const schema = z.string();
-  const result = schema.apply(capture, "id", 42);
-
-  expect(calls[0]).toBe(schema);
-  expect(calls[1]).toBe("id");
-  expect(calls[2]).toBe(42);
-  expect(z.parse(result, "value")).toBe("value");
-  expectTypeOf<z.infer<typeof result>>().toEqualTypeOf<string>();
-});
-
-test("apply type-checks the extra args", () => {
-  const withMin = (schema: z.ZodMiniString, n: number) => schema.check(z.minLength(n));
-
-  expect(z.parse(z.string().apply(withMin, 3), "abcd")).toBe("abcd");
-  expectTypeOf(
-    z.number().apply<z.ZodMiniNumber>((schema) => schema.check(z.minimum(0)))
-  ).toEqualTypeOf<z.ZodMiniNumber>();
-
-  // @ts-expect-error wrong arg type
-  z.string().apply(withMin, "3");
-  // @ts-expect-error missing arg
-  z.string().apply(withMin);
-  // @ts-expect-error extra arg for a single-parameter callback
-  z.string().apply((schema: z.ZodMiniString) => schema, 3);
-});

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

@@ -1,190 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-
-import * as z from "zod/mini";
-
-test("assignability", () => {
-  // $ZodString
-  z.string() satisfies z.core.$ZodString;
-
-  // $ZodNumber
-  z.number() satisfies z.core.$ZodNumber;
-
-  // $ZodBigInt
-  z.bigint() satisfies z.core.$ZodBigInt;
-
-  // $ZodBoolean
-  z.boolean() satisfies z.core.$ZodBoolean;
-
-  // $ZodDate
-  z.date() satisfies z.core.$ZodDate;
-
-  // $ZodSymbol
-  z.symbol() satisfies z.core.$ZodSymbol;
-
-  // $ZodUndefined
-  z.undefined() satisfies z.core.$ZodUndefined;
-
-  // $ZodNullable
-  z.nullable(z.string()) satisfies z.core.$ZodNullable;
-
-  // $ZodNull
-  z.null() satisfies z.core.$ZodNull;
-
-  // $ZodAny
-  z.any() satisfies z.core.$ZodAny;
-
-  // $ZodUnknown
-  z.unknown() satisfies z.core.$ZodUnknown;
-
-  // $ZodNever
-  z.never() satisfies z.core.$ZodNever;
-
-  // $ZodVoid
-  z.void() satisfies z.core.$ZodVoid;
-
-  // $ZodArray
-  z.array(z.string()) satisfies z.core.$ZodArray;
-
-  // $ZodObject
-  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
-
-  // $ZodUnion
-  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
-
-  // $ZodIntersection
-  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
-
-  // $ZodTuple
-  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
-
-  // $ZodRecord
-  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
-
-  // $ZodMap
-  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
-
-  // $ZodSet
-  z.set(z.string()) satisfies z.core.$ZodSet;
-
-  // $ZodLiteral
-  z.literal("example") satisfies z.core.$ZodLiteral;
-
-  // $ZodEnum
-  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
-
-  // $ZodPromise
-  z.promise(z.string()) satisfies z.core.$ZodPromise;
-
-  // $ZodLazy
-  const lazySchema = z.lazy(() => z.string());
-  lazySchema satisfies z.core.$ZodLazy;
-
-  // $ZodOptional
-  z.optional(z.string()) satisfies z.core.$ZodOptional;
-
-  // $ZodDefault
-  z._default(z.string(), "default") satisfies z.core.$ZodDefault;
-
-  // $ZodTemplateLiteral
-  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
-
-  // $ZodCustom
-  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
-
-  // $ZodTransform
-  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
-
-  // $ZodNonOptional
-  z.nonoptional(z.optional(z.string())) satisfies z.core.$ZodNonOptional;
-
-  // $ZodReadonly
-  z.readonly(z.object({ key: z.string() })) satisfies z.core.$ZodReadonly;
-
-  // $ZodNaN
-  z.nan() satisfies z.core.$ZodNaN;
-
-  // $ZodPipe
-  z.pipe(z.unknown(), z.number()) satisfies z.core.$ZodPipe;
-
-  // $ZodSuccess
-  z.success(z.string()) satisfies z.core.$ZodSuccess;
-
-  // $ZodCatch
-  z.catch(z.string(), "fallback") satisfies z.core.$ZodCatch;
-
-  // $ZodFile
-  z.file() satisfies z.core.$ZodFile;
-});
-
-test("toZod", () => {
-  type Company = {
-    id: string;
-    name: string;
-    webAddress: string | null;
-  };
-
-  const CompanySchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    webAddress: z.nullable(z.string()),
-  });
-  const Company = z.toZod<Company>()(CompanySchema);
-
-  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
-
-  const CoreCompany = z.core.toZod<Company>()(CompanySchema);
-  expectTypeOf<z.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
-
-  const UtilCompany = z.core.util.toZod<Company>()(CompanySchema);
-  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
-
-  const Transformed = z.toZod<{ count: number }>()(
-    z.object({
-      count: z.pipe(
-        z.string(),
-        z.transform((value) => value.length)
-      ),
-    })
-  );
-  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
-  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
-
-  z.toZod<Company>()(
-    // @ts-expect-error missing optional keys still fail exact output matching
-    z.object({
-      id: z.string(),
-      name: z.string(),
-    })
-  );
-
-  z.toZod<Company>()(
-    // @ts-expect-error extra keys fail exact output matching
-    z.object({
-      id: z.string(),
-      name: z.string(),
-      webAddress: z.nullable(z.string()),
-      extra: z.string(),
-    })
-  );
-
-  z.toZod<Company>()(
-    // @ts-expect-error wrong property output fails matching
-    z.object({
-      id: z.number(),
-      name: z.string(),
-      webAddress: z.nullable(z.string()),
-    })
-  );
-});
-
-test("assignability with type narrowing", () => {
-  type _RefinedSchema<T extends z.ZodMiniType<object> | z.ZodMiniUnion> = T extends z.ZodMiniUnion
-    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
-    : T extends z.ZodMiniType<object>
-      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
-      : never;
-
-  type RefinedTypeSchema<T extends object> = T;
-
-  type RefinedUnionSchema<T extends z.ZodMiniUnion> = T;
-});

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

@@ -1,94 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-import * as z from "../index.js";
-
-test("branded types", () => {
-  const mySchema = z
-    .object({
-      name: z.string(),
-    })
-    .brand<"superschema">();
-
-  // simple branding
-  type MySchema = z.infer<typeof mySchema>;
-  // Using true for type equality assertion
-  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
-
-  const doStuff = (arg: MySchema) => arg;
-  doStuff(z.parse(mySchema, { name: "hello there" }));
-
-  // inheritance
-  const extendedSchema = mySchema.brand<"subschema">();
-  type ExtendedSchema = z.infer<typeof extendedSchema>;
-  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema"> & z.$brand<"subschema">>();
-
-  doStuff(z.parse(extendedSchema, { name: "hello again" }));
-
-  // number branding
-  const numberSchema = z.number().brand<42>();
-  type NumberSchema = z.infer<typeof numberSchema>;
-  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
-
-  // symbol branding
-  const MyBrand: unique symbol = Symbol("hello");
-  type MyBrand = typeof MyBrand;
-  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
-  type SymbolBrand = z.infer<typeof symbolBrand>;
-  // number & { [z.$brand]: { sup: true, [MyBrand]: true } }
-  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.$brand<"sup"> & z.$brand<MyBrand>>();
-
-  // keeping brands out of input types
-  const age = z.number().brand<"age">();
-  type Age1 = z.infer<typeof age>;
-  type AgeInput1 = z.input<typeof age>;
-
-  // Using not for type inequality assertion
-  expectTypeOf<AgeInput1>().not.toEqualTypeOf<Age1>();
-  expectTypeOf<number>().toEqualTypeOf<AgeInput1>();
-  expectTypeOf<number & z.$brand<"age">>().toEqualTypeOf<Age1>();
-
-  // @ts-expect-error
-  doStuff({ name: "hello there!" });
-});
-
-test("brand direction: out (default)", () => {
-  const schema = z.string().brand<"A">();
-  type Input = z.input<typeof schema>;
-  type Output = z.output<typeof schema>;
-
-  // output is branded
-  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
-  // input is NOT branded (default behavior)
-  expectTypeOf<Input>().toEqualTypeOf<string>();
-});
-
-test("brand direction: out (explicit)", () => {
-  const schema = z.string().brand<"A", "out">();
-  type Input = z.input<typeof schema>;
-  type Output = z.output<typeof schema>;
-
-  // output is branded
-  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
-  // input is NOT branded
-  expectTypeOf<Input>().toEqualTypeOf<string>();
-});
-
-test("brand direction: in", () => {
-  const schema = z.string().brand<"A", "in">();
-  type Input = z.input<typeof schema>;
-  type Output = z.output<typeof schema>;
-
-  // input is branded
-  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
-  // output is NOT branded
-  expectTypeOf<Output>().toEqualTypeOf<string>();
-});
-
-test("brand direction: inout", () => {
-  const schema = z.string().brand<"A", "inout">();
-  type Input = z.input<typeof schema>;
-  type Output = z.output<typeof schema>;
-
-  // both are branded
-  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
-  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
-});

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

@@ -1,158 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "../index.js";
-
-// lt;
-test("z.lt", () => {
-  const a = z.number().check(z.lt(10));
-  expect(z.safeParse(a, 9).success).toEqual(true);
-  expect(z.safeParse(a, 9).data).toEqual(9);
-  expect(z.safeParse(a, 10).success).toEqual(false);
-});
-
-// lte;
-test("z.lte", () => {
-  const a = z.number().check(z.lte(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 11).success).toEqual(false);
-});
-
-// min;
-test("z.max", () => {
-  const a = z.number().check(z.maximum(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 11).success).toEqual(false);
-});
-
-// gt;
-test("z.gt", () => {
-  const a = z.number().check(z.gt(10));
-  expect(z.safeParse(a, 11).success).toEqual(true);
-  expect(z.safeParse(a, 11).data).toEqual(11);
-  expect(z.safeParse(a, 10).success).toEqual(false);
-});
-
-// gte;
-test("z.gte", () => {
-  const a = z.number().check(z.gte(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 9).success).toEqual(false);
-});
-
-test("z.gte/z.lte origin on a date schema with a numeric bound", () => {
-  const bound = new Date(Date.UTC(2022, 10, 5)).getTime();
-  const tooSmall = z.safeParse(z.date().check(z.gte(bound)), new Date(Date.UTC(2022, 10, 4)));
-  const tooBig = z.safeParse(z.date().check(z.lte(bound)), new Date(Date.UTC(2022, 10, 6)));
-  expect(tooSmall.error!.issues[0]).toMatchObject({ code: "too_small", origin: "date" });
-  expect(tooBig.error!.issues[0]).toMatchObject({ code: "too_big", origin: "date" });
-});
-
-// min;
-test("z.min", () => {
-  const a = z.number().check(z.minimum(10));
-  expect(z.safeParse(a, 10).success).toEqual(true);
-  expect(z.safeParse(a, 10).data).toEqual(10);
-  expect(z.safeParse(a, 9).success).toEqual(false);
-});
-
-// maxSize;
-test("z.maxLength", () => {
-  const a = z.array(z.string()).check(z.maxLength(3));
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
-});
-
-// minSize;
-test("z.minLength", () => {
-  const a = z.array(z.string()).check(z.minLength(3));
-  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-});
-
-// size;
-test("z.length", () => {
-  const a = z.array(z.string()).check(z.length(3));
-  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
-  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
-  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
-});
-
-// regex;
-test("z.regex", () => {
-  const a = z.string().check(z.regex(/^aaa$/));
-  expect(z.safeParse(a, "aaa")).toMatchObject({ success: true, data: "aaa" });
-  expect(z.safeParse(a, "aa")).toMatchObject({ success: false });
-});
-
-// includes;
-test("z.includes", () => {
-  const a = z.string().check(z.includes("asdf"));
-  z.parse(a, "qqqasdfqqq");
-  z.parse(a, "asdf");
-  z.parse(a, "qqqasdf");
-  z.parse(a, "asdfqqq");
-  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
-});
-
-// startsWith;
-test("z.startsWith", () => {
-  const a = z.string().check(z.startsWith("asdf"));
-  z.parse(a, "asdf");
-  z.parse(a, "asdfqqq");
-  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
-});
-
-// endsWith;
-test("z.endsWith", () => {
-  const a = z.string().check(z.endsWith("asdf"));
-  z.parse(a, "asdf");
-  z.parse(a, "qqqasdf");
-  expect(z.safeParse(a, "asdfqqq")).toMatchObject({ success: false });
-});
-
-// lowercase;
-test("z.lowercase", () => {
-  const a = z.string().check(z.lowercase());
-  z.parse(a, "asdf");
-  expect(z.safeParse(a, "ASDF")).toMatchObject({ success: false });
-});
-
-// uppercase;
-test("z.uppercase", () => {
-  const a = z.string().check(z.uppercase());
-  z.parse(a, "ASDF");
-  expect(z.safeParse(a, "asdf")).toMatchObject({ success: false });
-});
-
-// filename;
-// fileType;
-// overwrite;
-test("z.overwrite", () => {
-  const a = z.string().check(z.overwrite((val) => val.toUpperCase()));
-  expect(z.safeParse(a, "asdf")).toMatchObject({ data: "ASDF" });
-});
-
-// normalize;
-// trim;
-// toLowerCase;
-// toUpperCase;
-// property
-
-test("z.properties", () => {
-  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:"), hostname: z.string() }));
-  expect(z.safeParse(a, new URL("https://example.com")).success).toEqual(true);
-  expect(z.safeParse(a, new URL("http://example.com")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
-});
-
-test("abort early", () => {
-  const schema = z.string().check(
-    z.refine((val) => val.length > 1),
-    z.refine((val) => val.length > 2, { abort: true }),
-    z.refine((val) => val.length > 3)
-  );
-  const data = "";
-  const result = z.safeParse(schema, data);
-  expect(result.error!.issues.length).toEqual(2);
-});