@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/zod/src/v4/core/tests/locales/el.test.ts

@@ -204,8 +204,7 @@ test("Greek locale - other error cases", () => {
 test("Greek locale - invalid_type with instanceof (class-name expected)", () => {
   z.config(el());
 
-  // When `expected` starts with a capital letter, render an `instanceof` message,
-  // matching the convention used by most other locales (de, es, fr, it, etc.).
+  // When `expected` starts with a capital letter, render an `instanceof` message, matching the convention used by most other locales (de, es, fr, it, etc.).
   const dateSchema = z.instanceof(Date);
   const dateResult = dateSchema.safeParse("not a date");
   expect(dateResult.success).toBe(false);

package/node_modules/zod/src/v4/core/tests/locales/es.test.ts

@@ -109,8 +109,7 @@ test("Spanish locale - type name translations in invalid_type errors", () => {
 test("Spanish locale - fallback for unknown type names", () => {
   z.config(es());
 
-  // Test with a type that's not in the TypeNames dictionary
-  // This will test the fallback behavior
+  // Test with a type that's not in the TypeNames dictionary. This will test the fallback behavior
   const dateSchema = z.date().min(new Date("2025-01-01"));
   const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
   expect(dateResult.success).toBe(false);

package/node_modules/zod/src/v4/core/tests/locales/fr.test.ts

@@ -8,7 +8,7 @@ test("French locale - type name translations in too_small errors", () => {
   const stringResult = z.string().min(5).safeParse("abc");
   expect(stringResult.success).toBe(false);
   if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Trop petit : chaîne doit avoir >=5 caractères");
+    expect(stringResult.error.issues[0].message).toBe("Trop petit : chaîne de caractères doit avoir >=5 caractères");
   }
 
   const numberResult = z.number().min(10).safeParse(5);
@@ -39,7 +39,7 @@ test("French locale - type name translations in too_big errors", () => {
   const stringResult = z.string().max(3).safeParse("abcde");
   expect(stringResult.success).toBe(false);
   if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Trop grand : chaîne doit avoir <=3 caractères");
+    expect(stringResult.error.issues[0].message).toBe("Trop grand : chaîne de caractères doit avoir <=3 caractères");
   }
 
   const numberResult = z.number().max(10).safeParse(15);
@@ -61,7 +61,7 @@ test("French locale - type name translations in invalid_type errors", () => {
   const stringResult = z.string().safeParse(123);
   expect(stringResult.success).toBe(false);
   if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Entrée invalide : chaîne attendu, nombre reçu");
+    expect(stringResult.error.issues[0].message).toBe("Entrée invalide : chaîne de caractères attendu, nombre reçu");
   }
 
   const arrayResult = z.array(z.string()).safeParse({});

package/node_modules/zod/src/v4/core/tests/locales/parity.test.ts

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+
+// Every locale must carry an entry for each key `en` translates. Four keys have drifted this way already — `credit_card` (#5931), `mac` (#5440), `Sizable.map` (#5316) and Hebrew's `uuidv4`/`uuidv6`/`template_literal` — each shipped in `en` and left the rest behind, so the gap only surfaced as a raw key in a user's error message.
+//
+// The key lists are read out of `en.ts` rather than hardcoded, so adding a format to `en` extends this test automatically. That is the whole point: a hand-maintained list here would miss the next one exactly the way the last four were missed.
+
+const enSource = readFileSync(fileURLToPath(new URL("../../../locales/en.ts", import.meta.url)), "utf8");
+
+function keysOf(block: string): string[] {
+  const body = enSource.match(new RegExp(`const ${block}[^=]*= \\{([\\s\\S]*?)\\n  \\};`))?.[1];
+  if (!body) throw new Error(`could not read ${block} out of en.ts`);
+  return [...body.matchAll(/^\s{4}([a-z_0-9]+):/gm)].map((m) => m[1]!);
+}
+
+const locales = z.locales as unknown as Record<string, () => { localeError: z.core.$ZodErrorMap }>;
+const names = Object.keys(locales).filter((k) => typeof locales[k] === "function");
+const SENTINEL = "zzsentinelzz";
+
+/** True when the locale has no entry for `key`: the message is what the sentinel produces. */
+function fallsThrough(locale: string, key: string, build: (k: string) => unknown): boolean {
+  const map = locales[locale]!().localeError as (iss: unknown) => string | undefined;
+  const real = String(map(build(key)) ?? "");
+  const sentinel = String(map(build(SENTINEL)) ?? "");
+  return real === sentinel.split(SENTINEL).join(key);
+}
+
+const asFormat = (k: string) => ({ code: "invalid_format", format: k, input: "x", path: [] });
+const asSize = (k: string) => ({ code: "too_small", origin: k, minimum: 2, inclusive: true, input: null, path: [] });
+
+test.each([
+  ["FormatDictionary", keysOf("FormatDictionary"), asFormat],
+  ["Sizable", keysOf("Sizable"), asSize],
+] as const)("every locale translates each %s key that en translates", (_block, keys, build) => {
+  // A key `en` maps to its own name (emoji, nanoid, cuid, cuid2) renders identically whether or not a locale defines it, so omitting it is not drift.
+  const required = keys.filter((k) => !fallsThrough("en", k, build));
+  const gaps = required.flatMap((k) => names.filter((n) => fallsThrough(n, k, build)).map((n) => `${n}.${k}`));
+
+  expect(gaps).toEqual([]);
+});

package/node_modules/zod/src/v4/core/tests/locales/tk.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+import { parsedType } from "../../util.js";
+
+test("parsedType", () => {
+  expect(parsedType("string")).toBe("string");
+  expect(parsedType(1)).toBe("number");
+  expect(parsedType(true)).toBe("boolean");
+  expect(parsedType(null)).toBe("null");
+  expect(parsedType(undefined)).toBe("undefined");
+  expect(parsedType([])).toBe("array");
+  expect(parsedType({})).toBe("object");
+  expect(parsedType(new Date())).toBe("Date");
+  expect(parsedType(new Map())).toBe("Map");
+  expect(parsedType(new Set())).toBe("Set");
+  expect(parsedType(new Error())).toBe("Error");
+
+  const nullPrototype = Object.create(null);
+  expect(parsedType(nullPrototype)).toBe("object");
+
+  const doubleNullPrototype = Object.create(Object.create(null));
+  expect(parsedType(doubleNullPrototype)).toBe("object");
+
+  expect(parsedType(Number.NaN)).toBe("nan");
+});
+
+test("locales - tk", () => {
+  z.config(z.locales.tk());
+
+  const invalidType = z.number().safeParse("a");
+  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType.error!.issues[0].message).toBe("Nädogry baha: garaşylan number ýerine string alyndy");
+
+  const invalidType2 = z.string().safeParse(1);
+  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType2.error!.issues[0].message).toBe("Nädogry baha: garaşylan string ýerine number alyndy");
+
+  const invalidValue = z.enum(["a", "b"]).safeParse(1);
+  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
+  expect(invalidValue.error!.issues[0].message).toBe('Nädogry saýlaw: aşakdakylardan biri bolmaly: "a"|"b"');
+
+  const tooBig = z.number().max(10).safeParse(15);
+  expect(tooBig.error!.issues[0].code).toBe("too_big");
+  expect(tooBig.error!.issues[0].message).toBe("Has uly: garaşylýan number <= 10");
+
+  const tooSmall = z.number().min(10).safeParse(5);
+  expect(tooSmall.error!.issues[0].code).toBe("too_small");
+  expect(tooSmall.error!.issues[0].message).toBe("Has kiçi: garaşylýan number >= 10");
+
+  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
+  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatRegex.error!.issues[0].message).toBe("Nädogry setir: /abcd/ nusga laýyk bolmaly");
+
+  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
+  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidFormatStartsWith.error!.issues[0].message).toBe('Nädogry setir: "abcd" bilen başlamaly');
+
+  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
+  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
+  expect(notMultipleOf.error!.issues[0].message).toBe("Nädogry san: 3 bilen galyndysyz bölünmeli");
+
+  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
+  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
+  expect(unrecognizedKeys.error!.issues[0].message).toBe('Tanalmaýan açar: "c"');
+
+  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
+  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
+  expect(invalidUnion.error!.issues[0].message).toBe("Nädogry baha");
+});

package/node_modules/zod/src/v4/core/tests/treeshake.test.ts

@@ -0,0 +1,51 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import { expect, test } from "vitest";
+
+// These declarations are unreachable from a minimal schema, but esbuild only drops them because of details that read as noise: `@__PURE__` annotations, and the `anchor()` helper in regexes.ts that exists solely because esbuild will not drop an annotated call whose argument interpolates a variable. Inlining the helper or deleting an annotation silently puts them back with no other test going red.
+//
+// Rollup drops all of these regardless, so a rollup fixture would report no difference and prove nothing. This has to run under esbuild.
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const MINI = path.resolve(here, "../../../mini/index.ts");
+const CLASSIC = path.resolve(here, "../../../index.ts");
+
+async function bundle(entrypoint: string, source: string): Promise<string> {
+  const result = await build({
+    stdin: {
+      contents: source.replace("%ENTRY%", entrypoint),
+      loader: "ts",
+      resolveDir: here,
+    },
+    bundle: true,
+    minify: true,
+    format: "esm",
+    target: "es2020",
+    treeShaking: true,
+    write: false,
+    logLevel: "silent",
+  });
+  return result.outputFiles[0]!.text;
+}
+
+test("a minimal zod/mini schema drops the declarations it cannot reach", async () => {
+  const out = await bundle(MINI, `import * as z from "%ENTRY%";\nconsole.log(z.boolean().parse(true));`);
+
+  // Sanity check: the schema itself is present, so an empty bundle cannot pass this test.
+  expect(out).toContain("boolean");
+
+  expect(out, "core.ts `$brand` lost its @__PURE__ annotation").not.toContain("zod_brand");
+  expect(out, "util.ts `NUMBER_FORMAT_RANGES` escaped its @__PURE__ IIFE").not.toContain("MAX_SAFE_INTEGER");
+  expect(out, "regexes.ts `date` is pinned again — was `anchor()` inlined?").not.toContain("02-29");
+}, 30000);
+
+// `registries.ts` is dropped from the mini module graph entirely, so its two symbols are absent there before and after. Classic is the entrypoint that exercises them.
+test("a minimal classic schema drops the registry symbols", async () => {
+  const out = await bundle(CLASSIC, `import * as z from "%ENTRY%";\nconsole.log(z.boolean().parse(true));`);
+
+  expect(out).toContain("boolean");
+
+  expect(out, "registries.ts `$output` lost its @__PURE__ annotation").not.toContain("ZodOutput");
+  expect(out, "registries.ts `$input` lost its @__PURE__ annotation").not.toContain("ZodInput");
+}, 30000);

package/node_modules/zod/src/v4/core/tests/url-no-canparse.test.ts

@@ -0,0 +1,31 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+// schemas.ts resolves URL.canParse on first use, not at module load. Resetting the module registry gives the re-imported copy a fresh, unresolved `urlCanParseImpl`, so deleting URL.canParse before the first parse still selects the inline fallback branch (URL.canParse may be undefined on older runtimes).
+describe("z.url() with URL.canParse absent", () => {
+  const original = URL.canParse;
+
+  beforeEach(() => {
+    vi.resetModules();
+    // @ts-expect-error force the fallback branch (URL.canParse may be undefined on older runtimes)
+    delete URL.canParse;
+  });
+
+  afterEach(() => {
+    URL.canParse = original;
+  });
+
+  test("z.url() validates correctly without URL.canParse (runtime)", async () => {
+    expect(URL.canParse).toBeUndefined();
+    const z = await import("../../index.js");
+    expect(z.url().safeParse("https://example.com").success).toBe(true);
+    expect(z.url().safeParse("not a url").success).toBe(false);
+  });
+
+  test("z.url() validates correctly without URL.canParse (compiled)", async () => {
+    expect(URL.canParse).toBeUndefined();
+    const z = await import("../../index.js");
+    const compiled = z.compile(z.url());
+    expect(compiled.safeParse("https://example.com").success).toBe(true);
+    expect(compiled.safeParse("not a url").success).toBe(false);
+  });
+});