@loomhelm/multi-task-flow 0.2.7 → 0.2.8

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

@@ -1,243 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("globalRegistry", () => {
-  const reg = z.registry();
-
-  const a = z.string();
-  reg.add(a);
-  expect(reg.has(a)).toEqual(true);
-
-  reg.remove(a);
-  expect(reg.has(a)).toEqual(false);
-
-  a.register(z.globalRegistry, { field: "sup" });
-  expect(z.globalRegistry.has(a)).toEqual(true);
-  expect(z.globalRegistry.get(a)).toEqual({ field: "sup" });
-
-  z.globalRegistry.remove(a);
-  expect(z.globalRegistry.has(a)).toEqual(false);
-});
-
-test("globalRegistry is singleton and attached to globalThis", () => {
-  expect(z.globalRegistry).toBe((globalThis as any).__zod_globalRegistry);
-});
-
-test("z.registry", () => {
-  const fieldRegistry = z.registry<{ name: string; description: string }>();
-
-  const a = z.string();
-  fieldRegistry.add(a, { name: "hello", description: "world" });
-  const a_meta = fieldRegistry.get(a);
-  expect(a_meta).toEqual({ name: "hello", description: "world" });
-
-  fieldRegistry.remove(a);
-  expect(fieldRegistry.has(a)).toEqual(false);
-  expect(fieldRegistry.get(a)).toEqual(undefined);
-});
-
-test("z.registry no metadata", () => {
-  const fieldRegistry = z.registry();
-
-  const a = z.string();
-  fieldRegistry.add(a);
-  fieldRegistry.add(z.number());
-  expect(fieldRegistry.get(a)).toEqual(undefined);
-  expect(fieldRegistry.has(a)).toEqual(true);
-});
-
-test("z.registry with schema constraints", () => {
-  const fieldRegistry = z.registry<{ name: string; description: string }, z.ZodString>();
-
-  const a = z.string();
-  fieldRegistry.add(a, { name: "hello", description: "world" });
-  // @ts-expect-error
-  fieldRegistry.add(z.number(), { name: "test" });
-  // @ts-expect-error
-  z.number().register(fieldRegistry, { name: "test", description: "test" });
-});
-
-// test("z.namedRegistry", () => {
-//   const namedReg = z
-//     .namedRegistry<{ name: string; description: string }>()
-//     .add(z.string(), { name: "hello", description: "world" })
-//     .add(z.number(), { name: "number", description: "number" });
-
-//   expect(namedReg.get("hello")).toEqual({
-//     name: "hello",
-//     description: "world",
-//   });
-//   expect(namedReg.has("hello")).toEqual(true);
-//   expect(namedReg.get("number")).toEqual({
-//     name: "number",
-//     description: "number",
-//   });
-
-//   // @ts-expect-error
-//   namedReg.get("world");
-//   // @ts-expect-error
-//   expect(namedReg.get("world")).toEqual(undefined);
-
-//   const hello = namedReg.get("hello");
-//   expect(hello).toEqual({ name: "hello", description: "world" });
-//   expectTypeOf<typeof hello>().toEqualTypeOf<{
-//     name: "hello";
-//     description: "world";
-//   }>();
-//   expectTypeOf<typeof namedReg.items>().toEqualTypeOf<{
-//     hello: { name: "hello"; description: "world" };
-//     number: { name: "number"; description: "number" };
-//   }>();
-// });
-
-test("output type in registry meta", () => {
-  const reg = z.registry<{ out: z.$output }>();
-  const a = z.string();
-  reg.add(a, { out: "asdf" });
-  // @ts-expect-error
-  reg.add(a, 1234);
-  expectTypeOf(reg.get(a)).toEqualTypeOf<{ out: string } | undefined>();
-});
-
-test("output type in registry meta - objects and arrays", () => {
-  const reg = z.registry<{ name: string; examples: z.$output[] }>();
-  const a = z.string();
-  reg.add(a, { name: "hello", examples: ["world"] });
-
-  // @ts-expect-error
-  reg.add(a, { name: "hello", examples: "world" });
-  expectTypeOf(reg.get(a)).toEqualTypeOf<{ name: string; examples: string[] } | undefined>();
-});
-
-test("input type in registry meta", () => {
-  const reg = z.registry<{ in: z.$input }>();
-  const a = z.pipe(z.number(), z.transform(String));
-  reg.add(a, { in: 1234 });
-  // @ts-expect-error
-  reg.add(a, "1234");
-  expectTypeOf(reg.get(a)).toEqualTypeOf<{ in: number } | undefined>();
-});
-
-test("input type in registry meta - objects and arrays", () => {
-  const reg = z.registry<{ name: string; examples: z.$input[] }>();
-  const a = z.pipe(z.number(), z.transform(String));
-  reg.add(a, { name: "hello", examples: [1234] });
-
-  // @ts-expect-error
-  reg.add(a, { name: "hello", examples: "world" });
-  expectTypeOf(reg.get(a)).toEqualTypeOf<{ name: string; examples: number[] } | undefined>();
-});
-
-test(".meta method", () => {
-  const a1 = z.string();
-  const a2 = a1.meta({ name: "hello" });
-
-  expect(a1.meta()).toEqual(undefined);
-  expect(a2.meta()).toEqual({ name: "hello" });
-  expect(a1 === a2).toEqual(false);
-});
-
-test(".meta metadata does not bubble up", () => {
-  const a1 = z.string().meta({ name: "hello" });
-  const a2 = a1.optional();
-
-  expect(a1.meta()).toEqual({ name: "hello" });
-  expect(a2.meta()).toEqual(undefined);
-});
-
-test(".describe", () => {
-  const a1 = z.string();
-  const a2 = a1.describe("Hello");
-
-  expect(a1.description).toEqual(undefined);
-  expect(a2.description).toEqual("Hello");
-});
-
-test("inherit across clone", () => {
-  const A = z.string().meta({ a: true });
-  expect(A.meta()).toEqual({ a: true });
-  const B = A.meta({ b: true });
-  expect(B.meta()).toEqual({ a: true, b: true });
-  const C = B.describe("hello");
-  expect(C.meta()).toEqual({ a: true, b: true, description: "hello" });
-});
-
-test("loose examples", () => {
-  z.string().register(z.globalRegistry, {
-    examples: ["example"],
-  });
-});
-
-test("function meta without replacement", () => {
-  const myReg = z.registry<{
-    defaulter: (arg: string, test: boolean) => number;
-  }>();
-
-  const mySchema = z.date();
-  myReg.add(mySchema, {
-    defaulter: (arg, _test) => {
-      return arg.length;
-    },
-  });
-
-  expect(myReg.get(mySchema)!.defaulter("hello", true)).toEqual(5);
-});
-
-test("function meta with replacement", () => {
-  const myReg = z.registry<{
-    defaulter: (arg: z.$input, test: boolean) => z.$output;
-  }>();
-
-  const mySchema = z.string().transform((val) => val.length);
-  myReg.add(mySchema, {
-    defaulter: (arg, _test) => {
-      return arg.length;
-    },
-  });
-
-  expect(myReg.get(mySchema)!.defaulter("hello", true)).toEqual(5);
-});
-
-test("test .clear()", () => {
-  const reg = z.registry();
-  const a = z.string();
-  reg.add(a);
-  expect(reg.has(a)).toEqual(true);
-  reg.clear();
-  expect(reg.has(a)).toEqual(false);
-});
-
-test("re-registering same id silently overwrites", () => {
-  const reg = z.registry<z.core.GlobalMeta>();
-  const a = z.string();
-  const b = z.number();
-
-  reg.add(a, { id: "shared-id" });
-  reg.add(b, { id: "shared-id" });
-
-  // No error thrown, b now owns the id
-  expect(reg._idmap.get("shared-id")).toBe(b);
-});
-
-test("toJSONSchema throws on duplicate id across different schemas", () => {
-  const reg = z.registry<z.core.GlobalMeta>();
-  const a = z.string().register(reg, { id: "duplicate-id" });
-  const b = z.number().register(reg, { id: "duplicate-id" });
-
-  const wrapper = z.object({ a, b });
-
-  expect(() => z.toJSONSchema(wrapper, { metadata: reg })).toThrow(
-    'Duplicate schema id "duplicate-id" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.'
-  );
-});
-
-test("toJSONSchema allows same schema with same id", () => {
-  const reg = z.registry<z.core.GlobalMeta>();
-  const shared = z.string().register(reg, { id: "shared-id" });
-
-  const wrapper = z.object({ a: shared, b: shared });
-
-  // Should not throw - same schema instance used twice
-  const result = z.toJSONSchema(wrapper, { metadata: reg });
-  expect(result.$defs?.["shared-id"]).toBeDefined();
-});

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

@@ -1,196 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const stringSet = z.set(z.string());
-type stringSet = z.infer<typeof stringSet>;
-
-const minTwo = z.set(z.string()).min(2);
-const maxTwo = z.set(z.string()).max(2);
-const justTwo = z.set(z.string()).size(2);
-const nonEmpty = z.set(z.string()).nonempty();
-const nonEmptyMax = z.set(z.string()).nonempty().max(2);
-
-test("type inference", () => {
-  expectTypeOf<stringSet>().toEqualTypeOf<Set<string>>();
-});
-
-test("valid parse", () => {
-  const result = stringSet.safeParse(new Set(["first", "second"]));
-  expect(result.success).toEqual(true);
-  expect(result.data!.has("first")).toEqual(true);
-  expect(result.data!.has("second")).toEqual(true);
-  expect(result.data!.has("third")).toEqual(false);
-
-  expect(() => {
-    minTwo.parse(new Set(["a", "b"]));
-    minTwo.parse(new Set(["a", "b", "c"]));
-    maxTwo.parse(new Set(["a", "b"]));
-    maxTwo.parse(new Set(["a"]));
-    justTwo.parse(new Set(["a", "b"]));
-    nonEmpty.parse(new Set(["a"]));
-    nonEmptyMax.parse(new Set(["a"]));
-  }).not.toThrow();
-});
-
-test("valid parse async", async () => {
-  const result = await stringSet.spa(new Set(["first", "second"]));
-  expect(result.success).toEqual(true);
-  expect(result.data!.has("first")).toEqual(true);
-  expect(result.data!.has("second")).toEqual(true);
-  expect(result.data!.has("third")).toEqual(false);
-
-  const asyncResult = stringSet.safeParse(new Set(["first", "second"]));
-  expect(asyncResult.success).toEqual(true);
-  expect(asyncResult.data!.has("first")).toEqual(true);
-  expect(asyncResult.data!.has("second")).toEqual(true);
-  expect(asyncResult.data!.has("third")).toEqual(false);
-});
-
-test("valid parse: size-related methods", () => {
-  expect(() => {
-    minTwo.parse(new Set(["a", "b"]));
-    minTwo.parse(new Set(["a", "b", "c"]));
-    maxTwo.parse(new Set(["a", "b"]));
-    maxTwo.parse(new Set(["a"]));
-    justTwo.parse(new Set(["a", "b"]));
-    nonEmpty.parse(new Set(["a"]));
-    nonEmptyMax.parse(new Set(["a"]));
-  }).not.toThrow();
-
-  const sizeZeroResult = stringSet.parse(new Set());
-  expect(sizeZeroResult.size).toBe(0);
-
-  const sizeTwoResult = minTwo.parse(new Set(["a", "b"]));
-  expect(sizeTwoResult.size).toBe(2);
-});
-
-test("failing when parsing empty set in nonempty ", () => {
-  const result = nonEmpty.safeParse(new Set());
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_small");
-});
-
-test("failing when set is smaller than min() ", () => {
-  const result = minTwo.safeParse(new Set(["just_one"]));
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_small");
-});
-
-test("failing when set is bigger than max() ", () => {
-  const result = maxTwo.safeParse(new Set(["one", "two", "three"]));
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_big");
-  expect(
-    z
-      .set(z.string())
-      .max(1)
-      .safeParse(new Set([1, 2])).error!.issues
-  ).toMatchObject([{ code: "too_big" }]);
-});
-
-test("failing when set does not match size() ", () => {
-  expect(justTwo.safeParse(new Set(["one"])).error!.issues[0].message).toEqual(
-    "Too small: expected set to have exactly 2 items"
-  );
-  expect(justTwo.safeParse(new Set(["one", "two", "three"])).error!.issues[0].message).toEqual(
-    "Too big: expected set to have exactly 2 items"
-  );
-});
-
-test("doesn’t throw when an empty set is given", () => {
-  const result = stringSet.safeParse(new Set([]));
-  expect(result.success).toEqual(true);
-});
-
-test("throws when a Map is given", () => {
-  const result = stringSet.safeParse(new Map([]));
-  expect(result.success).toEqual(false);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "set",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected set, received Map"
-      }
-    ]]
-  `);
-});
-
-test("throws when the given set has invalid input", () => {
-  const result = stringSet.safeParse(new Set([Symbol()]));
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received symbol"
-      }
-    ]]
-  `);
-});
-
-test("throws when the given set has multiple invalid entries", () => {
-  const result = stringSet.safeParse(new Set([1, 2] as any[]));
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(2);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received number"
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received number"
-      }
-    ]]
-  `);
-});
-
-test("min/max", async () => {
-  const schema = z.set(z.string()).min(4).max(5);
-
-  const r1 = schema.safeParse(new Set(["a", "b", "c", "d"]));
-  expect(r1.success).toEqual(true);
-
-  const r2 = schema.safeParse(new Set(["a", "b", "c"]));
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected set to have >=4 items",
-        "minimum": 4,
-        "origin": "set",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r3 = schema.safeParse(new Set(["a", "b", "c", "d", "e", "f"]));
-  expect(r3.success).toEqual(false);
-  expect(r3.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 5,
-        "message": "Too big: expected set to have <=5 items",
-        "origin": "set",
-        "path": [],
-      },
-    ]
-  `);
-});

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v4/classic/tests/standard-schema.test.ts

@@ -1,153 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("length checks", async () => {
-  const schema = z.string();
-  const result = await schema["~standard"].validate(12);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [],
-        },
-      ],
-    }
-  `);
-});
-
-test("length checks", async () => {
-  const schema = z.string();
-  const result = await schema["~standard"].validate("asdf");
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "value": "asdf",
-    }
-  `);
-});
-
-test("length checks", async () => {
-  const schema = z.string().refine(async (val) => val.length > 5);
-  const result = await schema["~standard"].validate(12);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [],
-        },
-      ],
-    }
-  `);
-});
-
-test("length checks", async () => {
-  const schema = z.string().refine(async (val) => val.length > 5);
-  const result = await schema["~standard"].validate("234134134");
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "value": "234134134",
-    }
-  `);
-});
-
-test("schemas conform to StandardJSONSchemaV1", async () => {
-  const schema = z.codec(z.string(), z.number(), {
-    decode: (str) => Number.parseFloat(str),
-    encode: (num) => num.toString(),
-  });
-  expect(schema["~standard"].validate).toBeTypeOf("function");
-  expect(await schema["~standard"].validate("42")).toMatchInlineSnapshot(`
-		{
-		  "value": 42,
-		}
-	`);
-  expect(schema["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "string",
-		}
-	`);
-  expect(schema["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "number",
-		}
-	`);
-});
-
-test(".toJSONSchema() returns StandardJSONSchemaV1", async () => {
-  const codec = z.codec(z.string(), z.number(), {
-    decode: (str) => Number.parseFloat(str),
-    encode: (num) => num.toString(),
-  });
-  const result = codec.toJSONSchema();
-  expect(result["~standard"].validate).toBeTypeOf("function");
-  expect(await result["~standard"].validate("42")).toMatchInlineSnapshot(`
-		{
-		  "value": 42,
-		}
-	`);
-  expect(result["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "string",
-		}
-	`);
-  expect(result["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "number",
-		}
-	`);
-});
-
-test("z.toJSONSchema() returns StandardJSONSchemaV1", async () => {
-  const codec = z.codec(z.string(), z.number(), {
-    decode: (str) => Number.parseFloat(str),
-    encode: (num) => num.toString(),
-  });
-  const result = z.toJSONSchema(codec);
-  expect(result["~standard"].validate).toBeTypeOf("function");
-  expect(await result["~standard"].validate("42")).toMatchInlineSnapshot(`
-		{
-		  "value": 42,
-		}
-	`);
-  expect(result["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "string",
-		}
-	`);
-  expect(result["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
-		{
-		  "$schema": "https://json-schema.org/draft/2020-12/schema",
-		  "type": "number",
-		}
-	`);
-});
-
-test("a failing validate reports the same issues as safeParse, without a ZodError", async () => {
-  const schema = z.object({ name: z.string().min(3), age: z.number().refine(async (n) => n > 0) });
-  const input = { name: "ab", age: -1 };
-  const result = (await schema["~standard"].validate(input)) as { issues: unknown[] };
-  expect(result.issues).toEqual((await schema.safeParseAsync(input)).error!.issues);
-  expect(result).not.toHaveProperty("error");
-  const sync = z.string().min(3)["~standard"].validate("ab") as { issues: unknown[] };
-  expect(sync.issues).toEqual(z.string().min(3).safeParse("ab").error!.issues);
-});
-
-test("a synchronously throwing check rejects through ~standard instead of throwing", async () => {
-  const schema = z.string().refine(() => {
-    throw new Error("boom");
-  });
-  const result = schema["~standard"].validate("abc");
-  expect(result).toBeInstanceOf(Promise);
-  await expect(result as Promise<unknown>).rejects.toThrow("boom");
-});