@supersoniks/concorde 3.2.1 → 3.2.2

package/mcp-server/node_modules/zod/src/v3/tests/array.test.ts

@@ -1,71 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const minTwo = z.string().array().min(2);
-const maxTwo = z.string().array().max(2);
-const justTwo = z.string().array().length(2);
-const intNum = z.string().array().nonempty();
-const nonEmptyMax = z.string().array().nonempty().max(2);
-
-type t1 = z.infer<typeof nonEmptyMax>;
-util.assertEqual<[string, ...string[]], t1>(true);
-
-type t2 = z.infer<typeof minTwo>;
-util.assertEqual<string[], t2>(true);
-
-test("passing validations", () => {
-  minTwo.parse(["a", "a"]);
-  minTwo.parse(["a", "a", "a"]);
-  maxTwo.parse(["a", "a"]);
-  maxTwo.parse(["a"]);
-  justTwo.parse(["a", "a"]);
-  intNum.parse(["a"]);
-  nonEmptyMax.parse(["a"]);
-});
-
-test("failing validations", () => {
-  expect(() => minTwo.parse(["a"])).toThrow();
-  expect(() => maxTwo.parse(["a", "a", "a"])).toThrow();
-  expect(() => justTwo.parse(["a"])).toThrow();
-  expect(() => justTwo.parse(["a", "a", "a"])).toThrow();
-  expect(() => intNum.parse([])).toThrow();
-  expect(() => nonEmptyMax.parse([])).toThrow();
-  expect(() => nonEmptyMax.parse(["a", "a", "a"])).toThrow();
-});
-
-test("parse empty array in nonempty", () => {
-  expect(() =>
-    z
-      .array(z.string())
-      .nonempty()
-      .parse([] as any)
-  ).toThrow();
-});
-
-test("get element", () => {
-  justTwo.element.parse("asdf");
-  expect(() => justTwo.element.parse(12)).toThrow();
-});
-
-test("continue parsing despite array size error", () => {
-  const schema = z.object({
-    people: z.string().array().min(2),
-  });
-
-  const result = schema.safeParse({
-    people: [123],
-  });
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-  }
-});
-
-test("parse should fail given sparse array", () => {
-  const schema = z.array(z.string()).nonempty().min(1).max(3);
-
-  expect(() => schema.parse(new Array(3))).toThrow();
-});

package/mcp-server/node_modules/zod/src/v3/tests/async-parsing.test.ts

@@ -1,388 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-/// string
-const stringSchema = z.string();
-
-test("string async parse", async () => {
-  const goodData = "XXX";
-  const badData = 12;
-
-  const goodResult = await stringSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await stringSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// number
-const numberSchema = z.number();
-test("number async parse", async () => {
-  const goodData = 1234.2353;
-  const badData = "1234";
-
-  const goodResult = await numberSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await numberSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// bigInt
-const bigIntSchema = z.bigint();
-test("bigInt async parse", async () => {
-  const goodData = BigInt(145);
-  const badData = 134;
-
-  const goodResult = await bigIntSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await bigIntSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// boolean
-const booleanSchema = z.boolean();
-test("boolean async parse", async () => {
-  const goodData = true;
-  const badData = 1;
-
-  const goodResult = await booleanSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await booleanSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// date
-const dateSchema = z.date();
-test("date async parse", async () => {
-  const goodData = new Date();
-  const badData = new Date().toISOString();
-
-  const goodResult = await dateSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await dateSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// undefined
-const undefinedSchema = z.undefined();
-test("undefined async parse", async () => {
-  const goodData = undefined;
-  const badData = "XXX";
-
-  const goodResult = await undefinedSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(undefined);
-
-  const badResult = await undefinedSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// null
-const nullSchema = z.null();
-test("null async parse", async () => {
-  const goodData = null;
-  const badData = undefined;
-
-  const goodResult = await nullSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await nullSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// any
-const anySchema = z.any();
-test("any async parse", async () => {
-  const goodData = [{}];
-  // const badData = 'XXX';
-
-  const goodResult = await anySchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  // const badResult = await anySchema.safeParseAsync(badData);
-  // expect(badResult.success).toBe(false);
-  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// unknown
-const unknownSchema = z.unknown();
-test("unknown async parse", async () => {
-  const goodData = ["asdf", 124, () => {}];
-  // const badData = 'XXX';
-
-  const goodResult = await unknownSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  // const badResult = await unknownSchema.safeParseAsync(badData);
-  // expect(badResult.success).toBe(false);
-  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// void
-const voidSchema = z.void();
-test("void async parse", async () => {
-  const goodData = undefined;
-  const badData = 0;
-
-  const goodResult = await voidSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await voidSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// array
-const arraySchema = z.array(z.string());
-test("array async parse", async () => {
-  const goodData = ["XXX"];
-  const badData = "XXX";
-
-  const goodResult = await arraySchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await arraySchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// object
-const objectSchema = z.object({ string: z.string() });
-test("object async parse", async () => {
-  const goodData = { string: "XXX" };
-  const badData = { string: 12 };
-
-  const goodResult = await objectSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await objectSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// union
-const unionSchema = z.union([z.string(), z.undefined()]);
-test("union async parse", async () => {
-  const goodData = undefined;
-  const badData = null;
-
-  const goodResult = await unionSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await unionSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// record
-const recordSchema = z.record(z.object({}));
-test("record async parse", async () => {
-  const goodData = { adsf: {}, asdf: {} };
-  const badData = [{}];
-
-  const goodResult = await recordSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await recordSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// function
-const functionSchema = z.function();
-test("function async parse", async () => {
-  const goodData = () => {};
-  const badData = "XXX";
-
-  const goodResult = await functionSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(typeof goodResult.data).toEqual("function");
-
-  const badResult = await functionSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// literal
-const literalSchema = z.literal("asdf");
-test("literal async parse", async () => {
-  const goodData = "asdf";
-  const badData = "asdff";
-
-  const goodResult = await literalSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await literalSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// enum
-const enumSchema = z.enum(["fish", "whale"]);
-test("enum async parse", async () => {
-  const goodData = "whale";
-  const badData = "leopard";
-
-  const goodResult = await enumSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await enumSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// nativeEnum
-enum nativeEnumTest {
-  asdf = "qwer",
-}
-// @ts-ignore
-const nativeEnumSchema = z.nativeEnum(nativeEnumTest);
-test("nativeEnum async parse", async () => {
-  const goodData = nativeEnumTest.asdf;
-  const badData = "asdf";
-
-  const goodResult = await nativeEnumSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
-
-  const badResult = await nativeEnumSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(false);
-  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
-});
-
-/// promise
-const promiseSchema = z.promise(z.number());
-test("promise async parse good", async () => {
-  const goodData = Promise.resolve(123);
-
-  const goodResult = await promiseSchema.safeParseAsync(goodData);
-  expect(goodResult.success).toBe(true);
-  if (goodResult.success) {
-    expect(goodResult.data).toBeInstanceOf(Promise);
-    const data = await goodResult.data;
-    expect(data).toEqual(123);
-    // expect(goodResult.data).resolves.toEqual(124);
-    // return goodResult.data;
-  } else {
-    throw new Error("success should be true");
-  }
-});
-
-test("promise async parse bad", async () => {
-  const badData = Promise.resolve("XXX");
-  const badResult = await promiseSchema.safeParseAsync(badData);
-  expect(badResult.success).toBe(true);
-  if (badResult.success) {
-    await expect(badResult.data).rejects.toBeInstanceOf(z.ZodError);
-  } else {
-    throw new Error("success should be true");
-  }
-});
-
-test("async validation non-empty strings", async () => {
-  const base = z.object({
-    hello: z.string().refine((x) => x && x.length > 0),
-    foo: z.string().refine((x) => x && x.length > 0),
-  });
-
-  const testval = { hello: "", foo: "" };
-  const result1 = base.safeParse(testval);
-  const result2 = base.safeParseAsync(testval);
-
-  const r1 = result1;
-  await result2.then((r2) => {
-    if (r1.success === false && r2.success === false) expect(r1.error.issues.length).toBe(r2.error.issues.length); // <--- r1 has length 2, r2 has length 1
-  });
-});
-
-test("async validation multiple errors 1", async () => {
-  const base = z.object({
-    hello: z.string(),
-    foo: z.number(),
-  });
-
-  const testval = { hello: 3, foo: "hello" };
-  const result1 = base.safeParse(testval);
-  const result2 = base.safeParseAsync(testval);
-
-  const r1 = result1;
-  await result2.then((r2) => {
-    if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length);
-  });
-});
-
-test("async validation multiple errors 2", async () => {
-  const base = (is_async?: boolean) =>
-    z.object({
-      hello: z.string(),
-      foo: z.object({
-        bar: z.number().refine(is_async ? async () => false : () => false),
-      }),
-    });
-
-  const testval = { hello: 3, foo: { bar: 4 } };
-  const result1 = base().safeParse(testval);
-  const result2 = base(true).safeParseAsync(testval);
-
-  const r1 = result1;
-  await result2.then((r2) => {
-    if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length);
-  });
-});
-
-test("ensure early async failure prevents follow-up refinement checks", async () => {
-  let count = 0;
-  const base = z.object({
-    hello: z.string(),
-    foo: z
-      .number()
-      .refine(async () => {
-        count++;
-        return true;
-      })
-      .refine(async () => {
-        count++;
-        return true;
-      }, "Good"),
-  });
-
-  const testval = { hello: "bye", foo: 3 };
-  const result = await base.safeParseAsync(testval);
-  if (result.success === false) {
-    expect(result.error.issues.length).toBe(1);
-    expect(count).toBe(1);
-  }
-
-  // await result.then((r) => {
-  //   if (r.success === false) expect(r.error.issues.length).toBe(1);
-  //   expect(count).toBe(2);
-  // });
-});

package/mcp-server/node_modules/zod/src/v3/tests/async-refinements.test.ts

@@ -1,46 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("parse async test", async () => {
-  const schema1 = z.string().refine(async (_val) => false);
-  expect(() => schema1.parse("asdf")).toThrow();
-
-  const schema2 = z.string().refine((_val) => Promise.resolve(true));
-  return await expect(() => schema2.parse("asdf")).toThrow();
-});
-
-test("parseAsync async test", async () => {
-  const schema1 = z.string().refine(async (_val) => true);
-  await schema1.parseAsync("asdf");
-
-  const schema2 = z.string().refine(async (_val) => false);
-  return await expect(schema2.parseAsync("asdf")).rejects.toBeDefined();
-  // expect(async () => await schema2.parseAsync('asdf')).toThrow();
-});
-
-test("parseAsync async test", async () => {
-  // expect.assertions(2);
-
-  const schema1 = z.string().refine((_val) => Promise.resolve(true));
-  const v1 = await schema1.parseAsync("asdf");
-  expect(v1).toEqual("asdf");
-
-  const schema2 = z.string().refine((_val) => Promise.resolve(false));
-  await expect(schema2.parseAsync("asdf")).rejects.toBeDefined();
-
-  const schema3 = z.string().refine((_val) => Promise.resolve(true));
-  await expect(schema3.parseAsync("asdf")).resolves.toEqual("asdf");
-  return await expect(schema3.parseAsync("qwer")).resolves.toEqual("qwer");
-});
-
-test("parseAsync async with value", async () => {
-  const schema1 = z.string().refine(async (val) => {
-    return val.length > 5;
-  });
-  await expect(schema1.parseAsync("asdf")).rejects.toBeDefined();
-
-  const v = await schema1.parseAsync("asdf123");
-  return await expect(v).toEqual("asdf123");
-});

package/mcp-server/node_modules/zod/src/v3/tests/base.test.ts

@@ -1,29 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("type guard", () => {
-  const stringToNumber = z.string().transform((arg) => arg.length);
-
-  const s1 = z.object({
-    stringToNumber,
-  });
-  type t1 = z.input<typeof s1>;
-
-  const data = { stringToNumber: "asdf" };
-  const parsed = s1.safeParse(data);
-  if (parsed.success) {
-    util.assertEqual<typeof data, t1>(true);
-  }
-});
-
-test("test this binding", () => {
-  const callback = (predicate: (val: string) => boolean) => {
-    return predicate("hello");
-  };
-
-  expect(callback((value) => z.string().safeParse(value).success)).toBe(true); // true
-  expect(callback((value) => z.string().safeParse(value).success)).toBe(true); // true
-});

package/mcp-server/node_modules/zod/src/v3/tests/bigint.test.ts

@@ -1,55 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const gtFive = z.bigint().gt(BigInt(5));
-const gteFive = z.bigint().gte(BigInt(5));
-const ltFive = z.bigint().lt(BigInt(5));
-const lteFive = z.bigint().lte(BigInt(5));
-const positive = z.bigint().positive();
-const negative = z.bigint().negative();
-const nonnegative = z.bigint().nonnegative();
-const nonpositive = z.bigint().nonpositive();
-const multipleOfFive = z.bigint().multipleOf(BigInt(5));
-
-test("passing validations", () => {
-  z.bigint().parse(BigInt(1));
-  z.bigint().parse(BigInt(0));
-  z.bigint().parse(BigInt(-1));
-  gtFive.parse(BigInt(6));
-  gteFive.parse(BigInt(5));
-  gteFive.parse(BigInt(6));
-  ltFive.parse(BigInt(4));
-  lteFive.parse(BigInt(5));
-  lteFive.parse(BigInt(4));
-  positive.parse(BigInt(3));
-  negative.parse(BigInt(-2));
-  nonnegative.parse(BigInt(0));
-  nonnegative.parse(BigInt(7));
-  nonpositive.parse(BigInt(0));
-  nonpositive.parse(BigInt(-12));
-  multipleOfFive.parse(BigInt(15));
-});
-
-test("failing validations", () => {
-  expect(() => gtFive.parse(BigInt(5))).toThrow();
-  expect(() => gteFive.parse(BigInt(4))).toThrow();
-  expect(() => ltFive.parse(BigInt(5))).toThrow();
-  expect(() => lteFive.parse(BigInt(6))).toThrow();
-  expect(() => positive.parse(BigInt(0))).toThrow();
-  expect(() => positive.parse(BigInt(-2))).toThrow();
-  expect(() => negative.parse(BigInt(0))).toThrow();
-  expect(() => negative.parse(BigInt(3))).toThrow();
-  expect(() => nonnegative.parse(BigInt(-1))).toThrow();
-  expect(() => nonpositive.parse(BigInt(1))).toThrow();
-  expect(() => multipleOfFive.parse(BigInt(13))).toThrow();
-});
-
-test("min max getters", () => {
-  expect(z.bigint().min(BigInt(5)).minValue).toEqual(BigInt(5));
-  expect(z.bigint().min(BigInt(5)).min(BigInt(10)).minValue).toEqual(BigInt(10));
-
-  expect(z.bigint().max(BigInt(5)).maxValue).toEqual(BigInt(5));
-  expect(z.bigint().max(BigInt(5)).max(BigInt(1)).maxValue).toEqual(BigInt(1));
-});

package/mcp-server/node_modules/zod/src/v3/tests/branded.test.ts

@@ -1,53 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("branded types", () => {
-  const mySchema = z
-    .object({
-      name: z.string(),
-    })
-    .brand<"superschema">();
-
-  // simple branding
-  type MySchema = z.infer<typeof mySchema>;
-  util.assertEqual<MySchema, { name: string } & { [z.BRAND]: { superschema: true } }>(true);
-
-  const doStuff = (arg: MySchema) => arg;
-  doStuff(mySchema.parse({ name: "hello there" }));
-
-  // inheritance
-  const extendedSchema = mySchema.brand<"subschema">();
-  type ExtendedSchema = z.infer<typeof extendedSchema>;
-  util.assertEqual<ExtendedSchema, { name: string } & z.BRAND<"superschema"> & z.BRAND<"subschema">>(true);
-
-  doStuff(extendedSchema.parse({ name: "hello again" }));
-
-  // number branding
-  const numberSchema = z.number().brand<42>();
-  type NumberSchema = z.infer<typeof numberSchema>;
-  util.assertEqual<NumberSchema, number & { [z.BRAND]: { 42: true } }>(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 } }
-  util.assertEqual<SymbolBrand, number & z.BRAND<"sup"> & z.BRAND<MyBrand>>(true);
-
-  // keeping brands out of input types
-  const age = z.number().brand<"age">();
-
-  type Age = z.infer<typeof age>;
-  type AgeInput = z.input<typeof age>;
-
-  util.assertEqual<AgeInput, Age>(false);
-  util.assertEqual<number, AgeInput>(true);
-  util.assertEqual<number & z.BRAND<"age">, Age>(true);
-
-  // @ts-expect-error
-  doStuff({ name: "hello there!" });
-});