@highstate/designer 0.19.1 → 0.20.0

package/.output/server/node_modules/zod/v4/core/util.js

@@ -7,7 +7,7 @@ export function assertNotEqual(val) {
 }
 export function assertIs(_arg) { }
 export function assertNever(_x) {
-    throw new Error();
+    throw new Error("Unexpected value in exhaustive check");
 }
 export function assert(_) { }
 export function getEnumValues(entries) {
@@ -135,6 +135,14 @@ export function randomString(length = 10) {
 export function esc(str) {
     return JSON.stringify(str);
 }
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
 export const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
 export function isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -160,6 +168,8 @@ export function isPlainObject(o) {
     const ctor = o.constructor;
     if (ctor === undefined)
         return true;
+    if (typeof ctor !== "function")
+        return true;
     // modified prototype
     const prot = ctor.prototype;
     if (isObject(prot) === false)
@@ -317,6 +327,11 @@ export const BIGINT_FORMAT_RANGES = {
 };
 export function pick(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".pick() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
@@ -337,6 +352,11 @@ export function pick(schema, mask) {
 }
 export function omit(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".omit() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = { ...schema._zod.def.shape };
@@ -362,7 +382,14 @@ export function extend(schema, shape) {
     const checks = schema._zod.def.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-        throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+        // Only throw if new shape overlaps with existing shape
+        // Use getOwnPropertyDescriptor to check key existence without accessing values
+        const existingShape = schema._zod.def.shape;
+        for (const key in shape) {
+            if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+                throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+            }
+        }
     }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
@@ -370,7 +397,6 @@ export function extend(schema, shape) {
             assignProp(this, "shape", _shape); // self-caching
             return _shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }
@@ -378,15 +404,13 @@ export function safeExtend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to safeExtend: expected a plain object");
     }
-    const def = {
-        ...schema._zod.def,
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
             const _shape = { ...schema._zod.def.shape, ...shape };
             assignProp(this, "shape", _shape); // self-caching
             return _shape;
         },
-        checks: schema._zod.def.checks,
-    };
+    });
     return clone(schema, def);
 }
 export function merge(a, b) {
@@ -404,6 +428,12 @@ export function merge(a, b) {
     return clone(a, def);
 }
 export function partial(Class, schema, mask) {
+    const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".partial() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
@@ -473,7 +503,6 @@ export function required(Class, schema, mask) {
             assignProp(this, "shape", shape); // self-caching
             return shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }
@@ -535,6 +564,27 @@ export function getLengthableOrigin(input) {
         return "string";
     return "unknown";
 }
+export function parsedType(data) {
+    const t = typeof data;
+    switch (t) {
+        case "number": {
+            return Number.isNaN(data) ? "nan" : "number";
+        }
+        case "object": {
+            if (data === null) {
+                return "null";
+            }
+            if (Array.isArray(data)) {
+                return "array";
+            }
+            const obj = data;
+            if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+                return obj.constructor.name;
+            }
+        }
+    }
+    return t;
+}
 export function issue(...args) {
     const [iss, input, inst] = args;
     if (typeof iss === "string") {

package/.output/server/node_modules/zod/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
-    minor: 1,
-    patch: 12,
+    minor: 3,
+    patch: 6,
 };

package/.output/server/node_modules/zod/v4/locales/ar.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "number";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "array";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "مدخل",
         email: "بريد إلكتروني",
         url: "رابط",
@@ -59,10 +39,20 @@ const error = () => {
         jwt: "JWT",
         template_literal: "مدخل",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `مدخلات غير مقبولة: يفترض إدخال ${issue.expected}، ولكن تم إدخال ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `مدخلات غير مقبولة: يفترض إدخال instanceof ${issue.expected}، ولكن تم إدخال ${received}`;
+                }
+                return `مدخلات غير مقبولة: يفترض إدخال ${expected}، ولكن تم إدخال ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `مدخلات غير مقبولة: يفترض إدخال ${util.stringifyPrimitive(issue.values[0])}`;
@@ -92,7 +82,7 @@ const error = () => {
                     return `نَص غير مقبول: يجب أن يتضمَّن "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `نَص غير مقبول: يجب أن يطابق النمط ${_issue.pattern}`;
-                return `${Nouns[_issue.format] ?? issue.format} غير مقبول`;
+                return `${FormatDictionary[_issue.format] ?? issue.format} غير مقبول`;
             }
             case "not_multiple_of":
                 return `رقم غير مقبول: يجب أن يكون من مضاعفات ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/az.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "number";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "array";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "input",
         email: "email address",
         url: "URL",
@@ -59,10 +39,20 @@ const error = () => {
         jwt: "JWT",
         template_literal: "input",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Yanlış dəyər: gözlənilən ${issue.expected}, daxil olan ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Yanlış dəyər: gözlənilən instanceof ${issue.expected}, daxil olan ${received}`;
+                }
+                return `Yanlış dəyər: gözlənilən ${expected}, daxil olan ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Yanlış dəyər: gözlənilən ${util.stringifyPrimitive(issue.values[0])}`;
@@ -91,7 +81,7 @@ const error = () => {
                     return `Yanlış mətn: "${_issue.includes}" daxil olmalıdır`;
                 if (_issue.format === "regex")
                     return `Yanlış mətn: ${_issue.pattern} şablonuna uyğun olmalıdır`;
-                return `Yanlış ${Nouns[_issue.format] ?? issue.format}`;
+                return `Yanlış ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Yanlış ədəd: ${issue.divisor} ilə bölünə bilən olmalıdır`;

package/.output/server/node_modules/zod/v4/locales/be.js

@@ -52,27 +52,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "лік";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "масіў";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "увод",
         email: "email адрас",
         url: "URL",
@@ -102,10 +82,22 @@ const error = () => {
         jwt: "JWT",
         template_literal: "увод",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "лік",
+        array: "масіў",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Няправільны ўвод: чакаўся ${issue.expected}, атрымана ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Няправільны ўвод: чакаўся instanceof ${issue.expected}, атрымана ${received}`;
+                }
+                return `Няправільны ўвод: чакаўся ${expected}, атрымана ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Няправільны ўвод: чакалася ${util.stringifyPrimitive(issue.values[0])}`;
@@ -140,7 +132,7 @@ const error = () => {
                     return `Няправільны радок: павінен змяшчаць "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Няправільны радок: павінен адпавядаць шаблону ${_issue.pattern}`;
-                return `Няправільны ${Nouns[_issue.format] ?? issue.format}`;
+                return `Няправільны ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Няправільны лік: павінен быць кратным ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/bg.js

@@ -1,24 +1,4 @@
 import * as util from "../core/util.js";
-export const parsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "number": {
-            return Number.isNaN(data) ? "NaN" : "число";
-        }
-        case "object": {
-            if (Array.isArray(data)) {
-                return "масив";
-            }
-            if (data === null) {
-                return "null";
-            }
-            if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                return data.constructor.name;
-            }
-        }
-    }
-    return t;
-};
 const error = () => {
     const Sizable = {
         string: { unit: "символа", verb: "да съдържа" },
@@ -29,7 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
         regex: "вход",
         email: "имейл адрес",
         url: "URL",
@@ -59,10 +39,22 @@ const error = () => {
         jwt: "JWT",
         template_literal: "вход",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "число",
+        array: "масив",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Невалиден вход: очакван ${issue.expected}, получен ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Невалиден вход: очакван instanceof ${issue.expected}, получен ${received}`;
+                }
+                return `Невалиден вход: очакван ${expected}, получен ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Невалиден вход: очакван ${util.stringifyPrimitive(issue.values[0])}`;
@@ -104,7 +96,7 @@ const error = () => {
                     invalid_adj = "Невалидно";
                 if (_issue.format === "duration")
                     invalid_adj = "Невалидна";
-                return `${invalid_adj} ${Nouns[_issue.format] ?? issue.format}`;
+                return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Невалидно число: трябва да бъде кратно на ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/ca.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "number";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "array";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "entrada",
         email: "adreça electrònica",
         url: "URL",
@@ -59,11 +39,20 @@ const error = () => {
         jwt: "JWT",
         template_literal: "entrada",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Tipus invàlid: s'esperava ${issue.expected}, s'ha rebut ${parsedType(issue.input)}`;
-            // return `Tipus invàlid: s'esperava ${issue.expected}, s'ha rebut ${util.getParsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Tipus invàlid: s'esperava instanceof ${issue.expected}, s'ha rebut ${received}`;
+                }
+                return `Tipus invàlid: s'esperava ${expected}, s'ha rebut ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Valor invàlid: s'esperava ${util.stringifyPrimitive(issue.values[0])}`;
@@ -94,7 +83,7 @@ const error = () => {
                     return `Format invàlid: ha d'incloure "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Format invàlid: ha de coincidir amb el patró ${_issue.pattern}`;
-                return `Format invàlid per a ${Nouns[_issue.format] ?? issue.format}`;
+                return `Format invàlid per a ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Número invàlid: ha de ser múltiple de ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/cs.js

@@ -9,45 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "číslo";
-            }
-            case "string": {
-                return "řetězec";
-            }
-            case "boolean": {
-                return "boolean";
-            }
-            case "bigint": {
-                return "bigint";
-            }
-            case "function": {
-                return "funkce";
-            }
-            case "symbol": {
-                return "symbol";
-            }
-            case "undefined": {
-                return "undefined";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "pole";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "regulární výraz",
         email: "e-mailová adresa",
         url: "URL",
@@ -77,10 +39,24 @@ const error = () => {
         jwt: "JWT",
         template_literal: "vstup",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "číslo",
+        string: "řetězec",
+        function: "funkce",
+        array: "pole",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Neplatný vstup: očekáváno ${issue.expected}, obdrženo ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Neplatný vstup: očekáváno instanceof ${issue.expected}, obdrženo ${received}`;
+                }
+                return `Neplatný vstup: očekáváno ${expected}, obdrženo ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Neplatný vstup: očekáváno ${util.stringifyPrimitive(issue.values[0])}`;
@@ -111,7 +87,7 @@ const error = () => {
                     return `Neplatný řetězec: musí obsahovat "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Neplatný řetězec: musí odpovídat vzoru ${_issue.pattern}`;
-                return `Neplatný formát ${Nouns[_issue.format] ?? issue.format}`;
+                return `Neplatný formát ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Neplatné číslo: musí být násobkem ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/da.js

@@ -6,43 +6,10 @@ const error = () => {
         array: { unit: "elementer", verb: "indeholdt" },
         set: { unit: "elementer", verb: "indeholdt" },
     };
-    const TypeNames = {
-        string: "streng",
-        number: "tal",
-        boolean: "boolean",
-        array: "liste",
-        object: "objekt",
-        set: "sæt",
-        file: "fil",
-    };
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    function getTypeName(type) {
-        return TypeNames[type] ?? type;
-    }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "tal";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "liste";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-                return "objekt";
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "input",
         email: "e-mailadresse",
         url: "URL",
@@ -72,10 +39,27 @@ const error = () => {
         jwt: "JWT",
         template_literal: "input",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        string: "streng",
+        number: "tal",
+        boolean: "boolean",
+        array: "liste",
+        object: "objekt",
+        set: "sæt",
+        file: "fil",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Ugyldigt input: forventede ${getTypeName(issue.expected)}, fik ${getTypeName(parsedType(issue.input))}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Ugyldigt input: forventede instanceof ${issue.expected}, fik ${received}`;
+                }
+                return `Ugyldigt input: forventede ${expected}, fik ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Ugyldig værdi: forventede ${util.stringifyPrimitive(issue.values[0])}`;
@@ -83,7 +67,7 @@ const error = () => {
             case "too_big": {
                 const adj = issue.inclusive ? "<=" : "<";
                 const sizing = getSizing(issue.origin);
-                const origin = getTypeName(issue.origin);
+                const origin = TypeDictionary[issue.origin] ?? issue.origin;
                 if (sizing)
                     return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
                 return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue.maximum.toString()}`;
@@ -91,7 +75,7 @@ const error = () => {
             case "too_small": {
                 const adj = issue.inclusive ? ">=" : ">";
                 const sizing = getSizing(issue.origin);
-                const origin = getTypeName(issue.origin);
+                const origin = TypeDictionary[issue.origin] ?? issue.origin;
                 if (sizing) {
                     return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
                 }
@@ -107,7 +91,7 @@ const error = () => {
                     return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Ugyldig streng: skal matche mønsteret ${_issue.pattern}`;
-                return `Ugyldig ${Nouns[_issue.format] ?? issue.format}`;
+                return `Ugyldig ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Ugyldigt tal: skal være deleligt med ${issue.divisor}`;