@xyo-network/xl1-cli 1.16.25 → 1.16.26

package/dist/cli-min.mjs

@@ -20860,21 +20860,30 @@ const NEVER = Object.freeze({
 });
 function $constructor(name, initializer, params) {
     function init(inst, def) {
-        var _a;
-        Object.defineProperty(inst, "_zod", {
-            value: inst._zod ?? {},
-            enumerable: false,
-        });
-        (_a = inst._zod).traits ?? (_a.traits = new Set());
+        if (!inst._zod) {
+            Object.defineProperty(inst, "_zod", {
+                value: {
+                    def,
+                    constr: _,
+                    traits: new Set(),
+                },
+                enumerable: false,
+            });
+        }
+        if (inst._zod.traits.has(name)) {
+            return;
+        }
         inst._zod.traits.add(name);
         initializer(inst, def);
         // support prototype modifications
-        for (const k in _.prototype) {
-            if (!(k in inst))
-                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+        const proto = _.prototype;
+        const keys = Object.keys(proto);
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (!(k in inst)) {
+                inst[k] = proto[k].bind(inst);
+            }
         }
-        inst._zod.constr = _;
-        inst._zod.def = def;
     }
     // doesn't work if Parent has a constructor with arguments
     const Parent = params?.Parent ?? Object;
@@ -21057,6 +21066,14 @@ function randomString(length = 10) {
 function esc(str) {
     return JSON.stringify(str);
 }
+function slugify$1(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
 const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
 function isObject$3(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -21082,6 +21099,8 @@ function isPlainObject$1(o) {
     const ctor = o.constructor;
     if (ctor === undefined)
         return true;
+    if (typeof ctor !== "function")
+        return true;
     // modified prototype
     const prot = ctor.prototype;
     if (isObject$3(prot) === false)
@@ -21579,6 +21598,7 @@ var util$4 = /*#__PURE__*/Object.freeze({
   required: required$2,
   safeExtend: safeExtend,
   shallowClone: shallowClone,
+  slugify: slugify$1,
   stringifyPrimitive: stringifyPrimitive,
   uint8ArrayToBase64: uint8ArrayToBase64,
   uint8ArrayToBase64url: uint8ArrayToBase64url,
@@ -21898,6 +21918,10 @@ function emoji$1() {
 }
 const ipv4$2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 const ipv6$2 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+const mac$1 = (delimiter) => {
+    const escapedDelim = escapeRegex(delimiter ?? ":");
+    return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
+};
 const cidrv4$1 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
 const cidrv6$1 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 // https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
@@ -22013,6 +22037,7 @@ var regexes$1 = /*#__PURE__*/Object.freeze({
   ipv6: ipv6$2,
   ksuid: ksuid$1,
   lowercase: lowercase,
+  mac: mac$1,
   md5_base64: md5_base64,
   md5_base64url: md5_base64url,
   md5_hex: md5_hex,
@@ -22651,7 +22676,7 @@ class Doc {
 const version$8 = {
     major: 4,
     minor: 1,
-    patch: 12,
+    patch: 13,
 };
 
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -22854,7 +22879,7 @@ const $ZodURL = /*@__PURE__*/ $constructor("$ZodURL", (inst, def) => {
                         code: "invalid_format",
                         format: "url",
                         note: "Invalid hostname",
-                        pattern: hostname$5.source,
+                        pattern: def.hostname.source,
                         input: payload.value,
                         inst,
                         continue: !def.abort,
@@ -22944,18 +22969,12 @@ const $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def
 const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def) => {
     def.pattern ?? (def.pattern = ipv4$2);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv4`;
-    });
+    inst._zod.bag.format = `ipv4`;
 });
 const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def) => {
     def.pattern ?? (def.pattern = ipv6$2);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv6`;
-    });
+    inst._zod.bag.format = `ipv6`;
     inst._zod.check = (payload) => {
         try {
             // @ts-ignore
@@ -22973,6 +22992,11 @@ const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def) => {
         }
     };
 });
+const $ZodMAC = /*@__PURE__*/ $constructor("$ZodMAC", (inst, def) => {
+    def.pattern ?? (def.pattern = mac$1(def.delimiter));
+    $ZodStringFormat.init(inst, def);
+    inst._zod.bag.format = `mac`;
+});
 const $ZodCIDRv4 = /*@__PURE__*/ $constructor("$ZodCIDRv4", (inst, def) => {
     def.pattern ?? (def.pattern = cidrv4$1);
     $ZodStringFormat.init(inst, def);
@@ -23025,9 +23049,7 @@ function isValidBase64(data) {
 const $ZodBase64 = /*@__PURE__*/ $constructor("$ZodBase64", (inst, def) => {
     def.pattern ?? (def.pattern = base64$2);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64";
-    });
+    inst._zod.bag.contentEncoding = "base64";
     inst._zod.check = (payload) => {
         if (isValidBase64(payload.value))
             return;
@@ -23051,9 +23073,7 @@ function isValidBase64URL(data) {
 const $ZodBase64URL = /*@__PURE__*/ $constructor("$ZodBase64URL", (inst, def) => {
     def.pattern ?? (def.pattern = base64url$1);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64url";
-    });
+    inst._zod.bag.contentEncoding = "base64url";
     inst._zod.check = (payload) => {
         if (isValidBase64URL(payload.value))
             return;
@@ -23151,9 +23171,9 @@ const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
         return payload;
     };
 });
-const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
     $ZodCheckNumberFormat.init(inst, def);
-    $ZodNumber.init(inst, def); // no format checksp
+    $ZodNumber.init(inst, def); // no format checks
 });
 const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
     $ZodType.init(inst, def);
@@ -23196,7 +23216,7 @@ const $ZodBigInt = /*@__PURE__*/ $constructor("$ZodBigInt", (inst, def) => {
         return payload;
     };
 });
-const $ZodBigIntFormat = /*@__PURE__*/ $constructor("$ZodBigInt", (inst, def) => {
+const $ZodBigIntFormat = /*@__PURE__*/ $constructor("$ZodBigIntFormat", (inst, def) => {
     $ZodCheckBigIntFormat.init(inst, def);
     $ZodBigInt.init(inst, def); // no format checks
 });
@@ -23385,7 +23405,7 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
     const keySet = def.keySet;
     const _catchall = def.catchall._zod;
     const t = _catchall.def.type;
-    for (const key of Object.keys(input)) {
+    for (const key in input) {
         if (keySet.has(key))
             continue;
         if (t === "never") {
@@ -23773,7 +23793,6 @@ function handleIntersectionResults(result, left, right) {
 const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
     $ZodType.init(inst, def);
     const items = def.items;
-    const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
     inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
         if (!Array.isArray(input)) {
@@ -23787,6 +23806,8 @@ const $ZodTuple = /*@__PURE__*/ $constructor("$ZodTuple", (inst, def) => {
         }
         payload.value = [];
         const proms = [];
+        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
+        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
         if (!def.rest) {
             const tooBig = input.length > items.length;
             const tooSmall = input.length < optStart - 1;
@@ -23858,11 +23879,13 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
             return payload;
         }
         const proms = [];
-        if (def.keyType._zod.values) {
-            const values = def.keyType._zod.values;
+        const values = def.keyType._zod.values;
+        if (values) {
             payload.value = {};
+            const recordKeys = new Set();
             for (const key of values) {
                 if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+                    recordKeys.add(typeof key === "number" ? key.toString() : key);
                     const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
                     if (result instanceof Promise) {
                         proms.push(result.then((result) => {
@@ -23882,7 +23905,7 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
             }
             let unrecognized;
             for (const key in input) {
-                if (!values.has(key)) {
+                if (!recordKeys.has(key)) {
                     unrecognized = unrecognized ?? [];
                     unrecognized.push(key);
                 }
@@ -24066,13 +24089,14 @@ const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def) => {
     if (def.values.length === 0) {
         throw new Error("Cannot create literal schema with no valid values");
     }
-    inst._zod.values = new Set(def.values);
+    const values = new Set(def.values);
+    inst._zod.values = values;
     inst._zod.pattern = new RegExp(`^(${def.values
         .map((o) => (typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)))
         .join("|")})$`);
     inst._zod.parse = (payload, _ctx) => {
         const input = payload.value;
-        if (inst._zod.values.has(input)) {
+        if (values.has(input)) {
             return payload;
         }
         payload.issues.push({
@@ -24400,8 +24424,8 @@ const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
     defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-    defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-    defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+    defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
+    defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
     inst._zod.parse = (payload, ctx) => {
         if (ctx.direction === "backward") {
             return def.innerType._zod.run(payload, ctx);
@@ -24561,10 +24585,10 @@ const $ZodLazy = /*@__PURE__*/ $constructor("$ZodLazy", (inst, def) => {
     //   return () => _innerType;
     // });
     defineLazy(inst._zod, "innerType", () => def.getter());
-    defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
-    defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-    defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
-    defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
+    defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
+    defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
+    defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? undefined);
+    defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? undefined);
     inst._zod.parse = (payload, ctx) => {
         const inner = inst._zod.innerType;
         return inner._zod.run(payload, ctx);
@@ -25676,6 +25700,7 @@ const error$E = () => {
         duration: "ISO duration",
         ipv4: "IPv4 address",
         ipv6: "IPv6 address",
+        mac: "MAC address",
         cidrv4: "IPv4 range",
         cidrv6: "IPv6 range",
         base64: "base64-encoded string",
@@ -26485,111 +26510,222 @@ function frCA () {
 }
 
 const error$x = () => {
+    // Hebrew labels + grammatical gender
+    const TypeNames = {
+        string: { label: "מחרוזת", gender: "f" },
+        number: { label: "מספר", gender: "m" },
+        boolean: { label: "ערך בוליאני", gender: "m" },
+        bigint: { label: "BigInt", gender: "m" },
+        date: { label: "תאריך", gender: "m" },
+        array: { label: "מערך", gender: "m" },
+        object: { label: "אובייקט", gender: "m" },
+        null: { label: "ערך ריק (null)", gender: "m" },
+        undefined: { label: "ערך לא מוגדר (undefined)", gender: "m" },
+        symbol: { label: "סימבול (Symbol)", gender: "m" },
+        function: { label: "פונקציה", gender: "f" },
+        map: { label: "מפה (Map)", gender: "f" },
+        set: { label: "קבוצה (Set)", gender: "f" },
+        file: { label: "קובץ", gender: "m" },
+        promise: { label: "Promise", gender: "m" },
+        NaN: { label: "NaN", gender: "m" },
+        unknown: { label: "ערך לא ידוע", gender: "m" },
+        value: { label: "ערך", gender: "m" },
+    };
+    // Sizing units for size-related messages + localized origin labels
     const Sizable = {
-        string: { unit: "אותיות", verb: "לכלול" },
-        file: { unit: "בייטים", verb: "לכלול" },
-        array: { unit: "פריטים", verb: "לכלול" },
-        set: { unit: "פריטים", verb: "לכלול" },
+        string: { unit: "תווים", shortLabel: "קצר", longLabel: "ארוך" },
+        file: { unit: "בייטים", shortLabel: "קטן", longLabel: "גדול" },
+        array: { unit: "פריטים", shortLabel: "קטן", longLabel: "גדול" },
+        set: { unit: "פריטים", shortLabel: "קטן", longLabel: "גדול" },
+        number: { unit: "", shortLabel: "קטן", longLabel: "גדול" }, // no unit
     };
-    function getSizing(origin) {
+    // Helpers — labels, articles, and verbs
+    const typeEntry = (t) => (t ? TypeNames[t] : undefined);
+    const typeLabel = (t) => {
+        const e = typeEntry(t);
+        if (e)
+            return e.label;
+        // fallback: show raw string if unknown
+        return t ?? TypeNames.unknown.label;
+    };
+    const withDefinite = (t) => `ה${typeLabel(t)}`;
+    const verbFor = (t) => {
+        const e = typeEntry(t);
+        const gender = e?.gender ?? "m";
+        return gender === "f" ? "צריכה להיות" : "צריך להיות";
+    };
+    const getSizing = (origin) => {
+        if (!origin)
+            return null;
         return Sizable[origin] ?? null;
-    }
+    };
+    // Robust type parser for "received" — returns a key we understand or a constructor name
     const parsedType = (data) => {
         const t = typeof data;
         switch (t) {
-            case "number": {
+            case "number":
                 return Number.isNaN(data) ? "NaN" : "number";
-            }
             case "object": {
-                if (Array.isArray(data)) {
+                if (Array.isArray(data))
                     return "array";
-                }
-                if (data === null) {
+                if (data === null)
                     return "null";
-                }
                 if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
+                    return data.constructor.name; // keep as-is (e.g., "Date")
                 }
+                return "object";
             }
+            default:
+                return t;
         }
-        return t;
     };
     const Nouns = {
-        regex: "קלט",
-        email: "כתובת אימייל",
-        url: "כתובת רשת",
-        emoji: "אימוג'י",
-        uuid: "UUID",
-        uuidv4: "UUIDv4",
-        uuidv6: "UUIDv6",
-        nanoid: "nanoid",
-        guid: "GUID",
-        cuid: "cuid",
-        cuid2: "cuid2",
-        ulid: "ULID",
-        xid: "XID",
-        ksuid: "KSUID",
-        datetime: "תאריך וזמן ISO",
-        date: "תאריך ISO",
-        time: "זמן ISO",
-        duration: "משך זמן ISO",
-        ipv4: "כתובת IPv4",
-        ipv6: "כתובת IPv6",
-        cidrv4: "טווח IPv4",
-        cidrv6: "טווח IPv6",
-        base64: "מחרוזת בבסיס 64",
-        base64url: "מחרוזת בבסיס 64 לכתובות רשת",
-        json_string: "מחרוזת JSON",
-        e164: "מספר E.164",
-        jwt: "JWT",
-        template_literal: "קלט",
+        regex: { label: "קלט", gender: "m" },
+        email: { label: "כתובת אימייל", gender: "f" },
+        url: { label: "כתובת רשת", gender: "f" },
+        emoji: { label: "אימוג'י", gender: "m" },
+        uuid: { label: "UUID", gender: "m" },
+        nanoid: { label: "nanoid", gender: "m" },
+        guid: { label: "GUID", gender: "m" },
+        cuid: { label: "cuid", gender: "m" },
+        cuid2: { label: "cuid2", gender: "m" },
+        ulid: { label: "ULID", gender: "m" },
+        xid: { label: "XID", gender: "m" },
+        ksuid: { label: "KSUID", gender: "m" },
+        datetime: { label: "תאריך וזמן ISO", gender: "m" },
+        date: { label: "תאריך ISO", gender: "m" },
+        time: { label: "זמן ISO", gender: "m" },
+        duration: { label: "משך זמן ISO", gender: "m" },
+        ipv4: { label: "כתובת IPv4", gender: "f" },
+        ipv6: { label: "כתובת IPv6", gender: "f" },
+        cidrv4: { label: "טווח IPv4", gender: "m" },
+        cidrv6: { label: "טווח IPv6", gender: "m" },
+        base64: { label: "מחרוזת בבסיס 64", gender: "f" },
+        base64url: { label: "מחרוזת בבסיס 64 לכתובות רשת", gender: "f" },
+        json_string: { label: "מחרוזת JSON", gender: "f" },
+        e164: { label: "מספר E.164", gender: "m" },
+        jwt: { label: "JWT", gender: "m" },
+        ends_with: { label: "קלט", gender: "m" },
+        includes: { label: "קלט", gender: "m" },
+        lowercase: { label: "קלט", gender: "m" },
+        starts_with: { label: "קלט", gender: "m" },
+        uppercase: { label: "קלט", gender: "m" },
     };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `קלט לא תקין: צריך ${issue.expected}, התקבל ${parsedType(issue.input)}`;
-            // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
-            case "invalid_value":
-                if (issue.values.length === 1)
-                    return `קלט לא תקין: צריך ${stringifyPrimitive(issue.values[0])}`;
-                return `קלט לא תקין: צריך אחת מהאפשרויות  ${joinValues(issue.values, "|")}`;
+            case "invalid_type": {
+                // Expected type: show without definite article for clearer Hebrew
+                const expectedKey = issue.expected;
+                const expected = typeLabel(expectedKey);
+                // Received: show localized label if known, otherwise constructor/raw
+                const receivedKey = parsedType(issue.input);
+                const received = TypeNames[receivedKey]?.label ?? receivedKey;
+                return `קלט לא תקין: צריך להיות ${expected}, התקבל ${received}`;
+            }
+            case "invalid_value": {
+                if (issue.values.length === 1) {
+                    return `ערך לא תקין: הערך חייב להיות ${stringifyPrimitive(issue.values[0])}`;
+                }
+                // Join values with proper Hebrew formatting
+                const stringified = issue.values.map((v) => stringifyPrimitive(v));
+                if (issue.values.length === 2) {
+                    return `ערך לא תקין: האפשרויות המתאימות הן ${stringified[0]} או ${stringified[1]}`;
+                }
+                // For 3+ values: "a", "b" או "c"
+                const lastValue = stringified[stringified.length - 1];
+                const restValues = stringified.slice(0, -1).join(", ");
+                return `ערך לא תקין: האפשרויות המתאימות הן ${restValues} או ${lastValue}`;
+            }
             case "too_big": {
-                const adj = issue.inclusive ? "<=" : "<";
                 const sizing = getSizing(issue.origin);
-                if (sizing)
-                    return `גדול מדי: ${issue.origin ?? "value"} צריך להיות ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
-                return `גדול מדי: ${issue.origin ?? "value"} צריך להיות ${adj}${issue.maximum.toString()}`;
+                const subject = withDefinite(issue.origin ?? "value");
+                if (issue.origin === "string") {
+                    // Special handling for strings - more natural Hebrew
+                    return `${sizing?.longLabel ?? "ארוך"} מדי: ${subject} צריכה להכיל ${issue.maximum.toString()} ${sizing?.unit ?? ""} ${issue.inclusive ? "או פחות" : "לכל היותר"}`.trim();
+                }
+                if (issue.origin === "number") {
+                    // Natural Hebrew for numbers
+                    const comparison = issue.inclusive ? `קטן או שווה ל-${issue.maximum}` : `קטן מ-${issue.maximum}`;
+                    return `גדול מדי: ${subject} צריך להיות ${comparison}`;
+                }
+                if (issue.origin === "array" || issue.origin === "set") {
+                    // Natural Hebrew for arrays and sets
+                    const verb = issue.origin === "set" ? "צריכה" : "צריך";
+                    const comparison = issue.inclusive
+                        ? `${issue.maximum} ${sizing?.unit ?? ""} או פחות`
+                        : `פחות מ-${issue.maximum} ${sizing?.unit ?? ""}`;
+                    return `גדול מדי: ${subject} ${verb} להכיל ${comparison}`.trim();
+                }
+                const adj = issue.inclusive ? "<=" : "<";
+                const be = verbFor(issue.origin ?? "value");
+                if (sizing?.unit) {
+                    return `${sizing.longLabel} מדי: ${subject} ${be} ${adj}${issue.maximum.toString()} ${sizing.unit}`;
+                }
+                return `${sizing?.longLabel ?? "גדול"} מדי: ${subject} ${be} ${adj}${issue.maximum.toString()}`;
             }
             case "too_small": {
-                const adj = issue.inclusive ? ">=" : ">";
                 const sizing = getSizing(issue.origin);
-                if (sizing) {
-                    return `קטן מדי: ${issue.origin} צריך להיות ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+                const subject = withDefinite(issue.origin ?? "value");
+                if (issue.origin === "string") {
+                    // Special handling for strings - more natural Hebrew
+                    return `${sizing?.shortLabel ?? "קצר"} מדי: ${subject} צריכה להכיל ${issue.minimum.toString()} ${sizing?.unit ?? ""} ${issue.inclusive ? "או יותר" : "לפחות"}`.trim();
+                }
+                if (issue.origin === "number") {
+                    // Natural Hebrew for numbers
+                    const comparison = issue.inclusive ? `גדול או שווה ל-${issue.minimum}` : `גדול מ-${issue.minimum}`;
+                    return `קטן מדי: ${subject} צריך להיות ${comparison}`;
+                }
+                if (issue.origin === "array" || issue.origin === "set") {
+                    // Natural Hebrew for arrays and sets
+                    const verb = issue.origin === "set" ? "צריכה" : "צריך";
+                    // Special case for singular (minimum === 1)
+                    if (issue.minimum === 1 && issue.inclusive) {
+                        const singularPhrase = issue.origin === "set" ? "לפחות פריט אחד" : "לפחות פריט אחד";
+                        return `קטן מדי: ${subject} ${verb} להכיל ${singularPhrase}`;
+                    }
+                    const comparison = issue.inclusive
+                        ? `${issue.minimum} ${sizing?.unit ?? ""} או יותר`
+                        : `יותר מ-${issue.minimum} ${sizing?.unit ?? ""}`;
+                    return `קטן מדי: ${subject} ${verb} להכיל ${comparison}`.trim();
+                }
+                const adj = issue.inclusive ? ">=" : ">";
+                const be = verbFor(issue.origin ?? "value");
+                if (sizing?.unit) {
+                    return `${sizing.shortLabel} מדי: ${subject} ${be} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
                 }
-                return `קטן מדי: ${issue.origin} צריך להיות ${adj}${issue.minimum.toString()}`;
+                return `${sizing?.shortLabel ?? "קטן"} מדי: ${subject} ${be} ${adj}${issue.minimum.toString()}`;
             }
             case "invalid_format": {
                 const _issue = issue;
+                // These apply to strings — use feminine grammar + ה׳ הידיעה
                 if (_issue.format === "starts_with")
-                    return `מחרוזת לא תקינה: חייבת להתחיל ב"${_issue.prefix}"`;
+                    return `המחרוזת חייבת להתחיל ב "${_issue.prefix}"`;
                 if (_issue.format === "ends_with")
-                    return `מחרוזת לא תקינה: חייבת להסתיים ב "${_issue.suffix}"`;
+                    return `המחרוזת חייבת להסתיים ב "${_issue.suffix}"`;
                 if (_issue.format === "includes")
-                    return `מחרוזת לא תקינה: חייבת לכלול "${_issue.includes}"`;
+                    return `המחרוזת חייבת לכלול "${_issue.includes}"`;
                 if (_issue.format === "regex")
-                    return `מחרוזת לא תקינה: חייבת להתאים לתבנית ${_issue.pattern}`;
-                return `${Nouns[_issue.format] ?? issue.format} לא תקין`;
+                    return `המחרוזת חייבת להתאים לתבנית ${_issue.pattern}`;
+                // Handle gender agreement for formats
+                const nounEntry = Nouns[_issue.format];
+                const noun = nounEntry?.label ?? _issue.format;
+                const gender = nounEntry?.gender ?? "m";
+                const adjective = gender === "f" ? "תקינה" : "תקין";
+                return `${noun} לא ${adjective}`;
             }
             case "not_multiple_of":
                 return `מספר לא תקין: חייב להיות מכפלה של ${issue.divisor}`;
             case "unrecognized_keys":
                 return `מפתח${issue.keys.length > 1 ? "ות" : ""} לא מזוה${issue.keys.length > 1 ? "ים" : "ה"}: ${joinValues(issue.keys, ", ")}`;
-            case "invalid_key":
-                return `מפתח לא תקין ב${issue.origin}`;
+            case "invalid_key": {
+                return `שדה לא תקין באובייקט`;
+            }
             case "invalid_union":
                 return "קלט לא תקין";
-            case "invalid_element":
-                return `ערך לא תקין ב${issue.origin}`;
+            case "invalid_element": {
+                const place = withDefinite(issue.origin ?? "array");
+                return `ערך לא תקין ב${place}`;
+            }
             default:
                 return `קלט לא תקין`;
         }
@@ -28017,10 +28153,10 @@ function ms$1 () {
 
 const error$l = () => {
     const Sizable = {
-        string: { unit: "tekens" },
-        file: { unit: "bytes" },
-        array: { unit: "elementen" },
-        set: { unit: "elementen" },
+        string: { unit: "tekens", verb: "te hebben" },
+        file: { unit: "bytes", verb: "te hebben" },
+        array: { unit: "elementen", verb: "te hebben" },
+        set: { unit: "elementen", verb: "te hebben" },
     };
     function getSizing(origin) {
         return Sizable[origin] ?? null;
@@ -28087,16 +28223,16 @@ const error$l = () => {
                 const adj = issue.inclusive ? "<=" : "<";
                 const sizing = getSizing(issue.origin);
                 if (sizing)
-                    return `Te lang: verwacht dat ${issue.origin ?? "waarde"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementen"} bevat`;
-                return `Te lang: verwacht dat ${issue.origin ?? "waarde"} ${adj}${issue.maximum.toString()} is`;
+                    return `Te groot: verwacht dat ${issue.origin ?? "waarde"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementen"}`;
+                return `Te groot: verwacht dat ${issue.origin ?? "waarde"} ${adj}${issue.maximum.toString()} is`;
             }
             case "too_small": {
                 const adj = issue.inclusive ? ">=" : ">";
                 const sizing = getSizing(issue.origin);
                 if (sizing) {
-                    return `Te kort: verwacht dat ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} bevat`;
+                    return `Te klein: verwacht dat ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
                 }
-                return `Te kort: verwacht dat ${issue.origin} ${adj}${issue.minimum.toString()} is`;
+                return `Te klein: verwacht dat ${issue.origin} ${adj}${issue.minimum.toString()} is`;
             }
             case "invalid_format": {
                 const _issue = issue;
@@ -30222,6 +30358,7 @@ var index$2 = /*#__PURE__*/Object.freeze({
   zhTW: zhTW
 });
 
+var _a$3;
 const $output = Symbol("ZodOutput");
 const $input = Symbol("ZodInput");
 class $ZodRegistry {
@@ -30273,7 +30410,8 @@ class $ZodRegistry {
 function registry() {
     return new $ZodRegistry();
 }
-const globalRegistry = /*@__PURE__*/ registry();
+(_a$3 = globalThis).__zod_globalRegistry ?? (_a$3.__zod_globalRegistry = registry());
+const globalRegistry = globalThis.__zod_globalRegistry;
 
 function _string(Class, params) {
     return new Class({
@@ -30435,6 +30573,15 @@ function _ipv6(Class, params) {
         ...normalizeParams(params),
     });
 }
+function _mac(Class, params) {
+    return new Class({
+        type: "string",
+        format: "mac",
+        check: "string_format",
+        abort: false,
+        ...normalizeParams(params),
+    });
+}
 function _cidrv4(Class, params) {
     return new Class({
         type: "string",
@@ -30875,6 +31022,10 @@ function _toLowerCase() {
 function _toUpperCase() {
     return _overwrite((input) => input.toUpperCase());
 }
+// slugify
+function _slugify() {
+    return _overwrite((input) => slugify$1(input));
+}
 function _array(Class, element, params) {
     return new Class({
         type: "array",
@@ -31122,6 +31273,28 @@ function _check(fn, params) {
     ch._zod.check = fn;
     return ch;
 }
+function describe$1(description) {
+    const ch = new $ZodCheck({ check: "describe" });
+    ch._zod.onattach = [
+        (inst) => {
+            const existing = globalRegistry.get(inst) ?? {};
+            globalRegistry.add(inst, { ...existing, description });
+        },
+    ];
+    ch._zod.check = () => { }; // no-op check
+    return ch;
+}
+function meta$1(metadata) {
+    const ch = new $ZodCheck({ check: "meta" });
+    ch._zod.onattach = [
+        (inst) => {
+            const existing = globalRegistry.get(inst) ?? {};
+            globalRegistry.add(inst, { ...existing, ...metadata });
+        },
+    ];
+    ch._zod.check = () => { }; // no-op check
+    return ch;
+}
 function _stringbool(Classes, _params) {
     const params = normalizeParams(_params);
     let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -31440,11 +31613,19 @@ class JSONSchemaGenerator {
                     }
                     case "union": {
                         const json = _json;
+                        // Discriminated unions use oneOf (exactly one match) instead of anyOf (one or more matches)
+                        // because the discriminator field ensures mutual exclusivity between options in JSON Schema
+                        const isDiscriminated = def.discriminator !== undefined;
                         const options = def.options.map((x, i) => this.process(x, {
                             ...params,
-                            path: [...params.path, "anyOf", i],
+                            path: [...params.path, isDiscriminated ? "oneOf" : "anyOf", i],
                         }));
-                        json.anyOf = options;
+                        if (isDiscriminated) {
+                            json.oneOf = options;
+                        }
+                        else {
+                            json.anyOf = options;
+                        }
                         break;
                     }
                     case "intersection": {
@@ -31997,100 +32178,57 @@ function isTransforming(_schema, _ctx) {
     if (ctx.seen.has(_schema))
         return false;
     ctx.seen.add(_schema);
-    const schema = _schema;
-    const def = schema._zod.def;
-    switch (def.type) {
-        case "string":
-        case "number":
-        case "bigint":
-        case "boolean":
-        case "date":
-        case "symbol":
-        case "undefined":
-        case "null":
-        case "any":
-        case "unknown":
-        case "never":
-        case "void":
-        case "literal":
-        case "enum":
-        case "nan":
-        case "file":
-        case "template_literal":
-            return false;
-        case "array": {
-            return isTransforming(def.element, ctx);
-        }
-        case "object": {
-            for (const key in def.shape) {
-                if (isTransforming(def.shape[key], ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "union": {
-            for (const option of def.options) {
-                if (isTransforming(option, ctx))
-                    return true;
-            }
-            return false;
-        }
-        case "intersection": {
-            return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
-        }
-        case "tuple": {
-            for (const item of def.items) {
-                if (isTransforming(item, ctx))
-                    return true;
-            }
-            if (def.rest && isTransforming(def.rest, ctx))
+    const def = _schema._zod.def;
+    if (def.type === "transform")
+        return true;
+    if (def.type === "array")
+        return isTransforming(def.element, ctx);
+    if (def.type === "set")
+        return isTransforming(def.valueType, ctx);
+    if (def.type === "lazy")
+        return isTransforming(def.getter(), ctx);
+    if (def.type === "promise" ||
+        def.type === "optional" ||
+        def.type === "nonoptional" ||
+        def.type === "nullable" ||
+        def.type === "readonly" ||
+        def.type === "default" ||
+        def.type === "prefault") {
+        return isTransforming(def.innerType, ctx);
+    }
+    if (def.type === "intersection") {
+        return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
+    }
+    if (def.type === "record" || def.type === "map") {
+        return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
+    }
+    if (def.type === "pipe") {
+        return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
+    }
+    if (def.type === "object") {
+        for (const key in def.shape) {
+            if (isTransforming(def.shape[key], ctx))
                 return true;
-            return false;
-        }
-        case "record": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-        }
-        case "map": {
-            return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-        }
-        case "set": {
-            return isTransforming(def.valueType, ctx);
         }
-        // inner types
-        case "promise":
-        case "optional":
-        case "nonoptional":
-        case "nullable":
-        case "readonly":
-            return isTransforming(def.innerType, ctx);
-        case "lazy":
-            return isTransforming(def.getter(), ctx);
-        case "default": {
-            return isTransforming(def.innerType, ctx);
-        }
-        case "prefault": {
-            return isTransforming(def.innerType, ctx);
+        return false;
+    }
+    if (def.type === "union") {
+        for (const option of def.options) {
+            if (isTransforming(option, ctx))
+                return true;
         }
-        case "custom": {
-            return false;
+        return false;
+    }
+    if (def.type === "tuple") {
+        for (const item of def.items) {
+            if (isTransforming(item, ctx))
+                return true;
         }
-        case "transform": {
+        if (def.rest && isTransforming(def.rest, ctx))
             return true;
-        }
-        case "pipe": {
-            return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
-        }
-        case "success": {
-            return false;
-        }
-        case "catch": {
-            return false;
-        }
-        case "function": {
-            return false;
-        }
+        return false;
     }
-    throw new Error(`Unknown schema type: ${def.type}`);
+    return false;
 }
 
 var jsonSchema = /*#__PURE__*/Object.freeze({
@@ -32160,6 +32298,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   $ZodKSUID: $ZodKSUID,
   $ZodLazy: $ZodLazy,
   $ZodLiteral: $ZodLiteral,
+  $ZodMAC: $ZodMAC,
   $ZodMap: $ZodMap,
   $ZodNaN: $ZodNaN,
   $ZodNanoID: $ZodNanoID,
@@ -32260,6 +32399,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   _lowercase: _lowercase,
   _lt: _lt,
   _lte: _lte,
+  _mac: _mac,
   _map: _map,
   _max: _lte,
   _maxLength: _maxLength,
@@ -32301,6 +32441,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   _safeParseAsync: _safeParseAsync,
   _set: _set,
   _size: _size,
+  _slugify: _slugify,
   _startsWith: _startsWith,
   _string: _string,
   _stringFormat: _stringFormat,
@@ -32332,6 +32473,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   config: config$2,
   decode: decode$3,
   decodeAsync: decodeAsync$1,
+  describe: describe$1,
   encode: encode$2,
   encodeAsync: encodeAsync$1,
   flattenError: flattenError,
@@ -32342,6 +32484,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   isValidBase64URL: isValidBase64URL,
   isValidJWT: isValidJWT,
   locales: index$2,
+  meta: meta$1,
   parse: parse$3,
   parseAsync: parseAsync$1,
   prettifyError: prettifyError,
@@ -32564,6 +32707,7 @@ const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
     inst.normalize = (...args) => inst.check(_normalize(...args));
     inst.toLowerCase = () => inst.check(_toLowerCase());
     inst.toUpperCase = () => inst.check(_toUpperCase());
+    inst.slugify = () => inst.check(_slugify());
 });
 const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
     $ZodString.init(inst, def);
@@ -32718,6 +32862,14 @@ const ZodIPv4 = /*@__PURE__*/ $constructor("ZodIPv4", (inst, def) => {
 function ipv4$1(params) {
     return _ipv4(ZodIPv4, params);
 }
+const ZodMAC = /*@__PURE__*/ $constructor("ZodMAC", (inst, def) => {
+    // ZodStringFormat.init(inst, def);
+    $ZodMAC.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+function mac(params) {
+    return _mac(ZodMAC, params);
+}
 const ZodIPv6 = /*@__PURE__*/ $constructor("ZodIPv6", (inst, def) => {
     // ZodStringFormat.init(inst, def);
     $ZodIPv6.init(inst, def);
@@ -33459,6 +33611,9 @@ function refine$1(fn, _params = {}) {
 function superRefine(fn) {
     return _superRefine(fn);
 }
+// Re-export describe and meta from core
+const describe = describe$1;
+const meta = meta$1;
 function _instanceof(cls, params = {
     error: `Input not instance of ${cls.name}`,
 }) {
@@ -33593,6 +33748,7 @@ var z = /*#__PURE__*/Object.freeze({
   ZodKSUID: ZodKSUID,
   ZodLazy: ZodLazy,
   ZodLiteral: ZodLiteral,
+  ZodMAC: ZodMAC,
   ZodMap: ZodMap,
   ZodNaN: ZodNaN,
   ZodNanoID: ZodNanoID,
@@ -33651,6 +33807,7 @@ var z = /*#__PURE__*/Object.freeze({
   date: date$1,
   decode: decode$2,
   decodeAsync: decodeAsync,
+  describe: describe,
   discriminatedUnion: discriminatedUnion,
   e164: e164,
   email: email,
@@ -33695,9 +33852,11 @@ var z = /*#__PURE__*/Object.freeze({
   lowercase: _lowercase,
   lt: _lt,
   lte: _lte,
+  mac: mac,
   map: map$3,
   maxLength: _maxLength,
   maxSize: _maxSize,
+  meta: meta,
   mime: _mime,
   minLength: _minLength,
   minSize: _minSize,
@@ -33743,6 +33902,7 @@ var z = /*#__PURE__*/Object.freeze({
   set: set$1,
   setErrorMap: setErrorMap,
   size: _size,
+  slugify: _slugify,
   startsWith: _startsWith,
   strictObject: strictObject,
   string: string$2,
@@ -67402,7 +67562,7 @@ function zodAsFactory(zod, name) {
   function asFunc(value, assert) {
     const result = zod.safeParse(value);
     if (result.success) {
-      return result.data;
+      return value;
     }
     if (assert !== void 0) {
       let assertConfig;
@@ -67437,10 +67597,59 @@ function zodAsFactory(zod, name) {
 function zodIsFactory(zod) {
   return (value) => zod.safeParse(value).success;
 }
-
-// src/zodToFactory.ts
 function zodToFactory(zod, name) {
-  return zodAsFactory(zod, name);
+  const as = zodAsFactory(zod, name);
+  function toFunc(value, assert) {
+    if (isDefined(assert)) {
+      return as(value, assert);
+    }
+    return as(value);
+  }
+  return toFunc;
+}
+function zodAsAsyncFactory(zod, name) {
+  async function asFunc(value, assert) {
+    const result = await zod.safeParseAsync(value);
+    if (result.success) {
+      return value;
+    }
+    if (assert !== void 0) {
+      let assertConfig;
+      switch (typeof assert) {
+        case "string": {
+          assertConfig = `[${name}][${value}] ${assert}`;
+          break;
+        }
+        case "object": {
+          assertConfig = `[${name}][${assert.name}][${value}] ${result.error.message}`;
+          break;
+        }
+        case "boolean": {
+          assertConfig = `[${name}][${value}] ${result.error.message}`;
+          break;
+        }
+        case "function": {
+          assertConfig = assert(value, result.error.message);
+          break;
+        }
+        default: {
+          assertConfig = true;
+        }
+      }
+      return assertError(value, assertConfig, result.error.message);
+    }
+  }
+  return asFunc;
+}
+function zodToAsyncFactory(zod, name) {
+  const as = zodAsAsyncFactory(zod, name);
+  async function toFunc(value, assert) {
+    if (isDefined(assert)) {
+      return await as(value, assert);
+    }
+    return await as(value);
+  }
+  return toFunc;
 }
 
 var object_model_star = /*#__PURE__*/Object.freeze({
@@ -71319,7 +71528,7 @@ function WithHashMetaZod(valueZod) {
 }
 var PayloadZodStrict = z.strictObject({ schema: SchemaZod });
 var PayloadZodLoose = z.looseObject({ schema: SchemaZod });
-var PayloadZodOfSchema$1 = (schema) => PayloadZod.extend({ schema: z.literal(schema) });
+var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z.literal(schema) });
 var PayloadZodStrictOfSchema = (schema) => PayloadZodStrict.extend({ schema: z.literal(schema) });
 var PayloadZodLooseOfSchema = (schema) => PayloadZodLoose.extend({ schema: z.literal(schema) });
 
@@ -71329,7 +71538,7 @@ var PayloadBundleFieldsZod = z.object({
   payloads: PayloadZodLoose.array(),
   root: HashZod
 });
-PayloadZodOfSchema$1(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape);
+PayloadZodOfSchema(PayloadBundleSchema).extend(PayloadBundleFieldsZod.shape);
 
 // src/Builder.ts
 var omitSchema = (payload) => {
@@ -73639,20 +73848,6 @@ var isExecutable = (value) => {
 var HashSchema = "network.xyo.hash";
 var isHashPayload = isPayloadOfSchemaType(HashSchema);
 var StepCompleteSchema = "network.xyo.chain.step.complete";
-var TransferSchema = "network.xyo.transfer";
-var TransferFieldsZod = z.object({
-  $opCodes: z.array(z.string()).optional(),
-  context: JsonObjectZod.optional(),
-  epoch: z.number(),
-  from: AddressZod,
-  transfers: z.record(AddressZod, HexZod)
-});
-var PayloadZodOfSchema = (schema) => PayloadZod.extend({ schema: z.literal(schema) });
-var TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
-var isTransfer = isPayloadOfSchemaType(TransferSchema);
-var asTransfer = AsObjectFactory.create(isTransfer);
-
-// src/payload/elevatable/Time.ts
 var TimeSchema = "network.xyo.time";
 var XL1TimeFieldsZod = z.object({
   // block number
@@ -73679,6 +73874,17 @@ var isTimePayload = (value) => {
   return isPayloadOfSchemaType(TimeSchema)(value) && isSafeEpoch(value.epoch);
 };
 var asTimePayload = AsObjectFactory.create(isTimePayload);
+var TransferSchema = "network.xyo.transfer";
+var TransferFieldsZod = z.object({
+  $opCodes: z.array(z.string()).optional(),
+  context: JsonObjectZod.optional(),
+  epoch: z.number(),
+  from: AddressZod,
+  transfers: z.record(AddressZod, HexZod)
+});
+var TransferZod = PayloadZodOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
+var isTransfer = isPayloadOfSchemaType(TransferSchema);
+var asTransfer = AsObjectFactory.create(isTransfer);
 var NumberishZod = z.union([z.number(), z.string(), z.bigint()]).transform((v) => typeof v === "bigint" ? Number(v) : typeof v === "string" ? Number(v) : v).pipe(z.number());
 
 // src/model/BlockNumber/BlockNumber.ts
@@ -73741,7 +73947,7 @@ var JsonToArrayBufferZod = string$2().transform((x) => {
 });
 var ChainZod = string$2().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 
-// src/zod/BlockBoundWitness.ts
+// src/zod/block/BlockBoundWitness.ts
 var BlockBoundWitnessFieldsZod = object$3({
   block: XL1BlockNumberZod,
   chain: ChainZod,
@@ -73758,19 +73964,36 @@ var isBlockBoundWitnessWithHashMeta = zodIsFactory(BlockBoundWitnessWithHashMeta
 var asBlockBoundWitnessWithHashMeta = zodAsFactory(BlockBoundWitnessWithHashMetaZod, "asBlockBoundWitnessWithHashMeta");
 var BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var asBlockBoundWitnessWithStorageMeta = zodAsFactory(BlockBoundWitnessWithStorageMetaZod, "asBlockBoundWitnessWithStorageMeta");
-var UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
-UnsignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
-UnsignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var SignedBlockBoundWitnessZod = SignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
+var isSignedBlockBoundWitness = zodIsFactory(SignedBlockBoundWitnessZod);
 var asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, "asSignedBlockBoundWitness");
 var SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape);
 var isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBoundWitnessWithHashMetaZod);
+SignedBlockBoundWitnessZod.transform(async (data) => {
+  if (isSignedBlockBoundWitnessWithHashMeta(data)) {
+    return data;
+  }
+  if (isSignedBlockBoundWitness(data)) {
+    return await PayloadBuilder.addHashMeta(data);
+  }
+  throw new Error("Invalid SignedBlockBoundWitnessWithHashMetaish format");
+});
 var SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape);
 var isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory(SignedBlockBoundWitnessWithStorageMetaZod);
 var asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory(
   SignedBlockBoundWitnessWithStorageMetaZod,
   "asSignedBlockBoundWitnessWithStorageMeta"
 );
+SignedBlockBoundWitnessZod.transform(async (data) => {
+  if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
+    return data;
+  }
+  if (isSignedBlockBoundWitness(data)) {
+    return await PayloadBuilder.addStorageMeta(data);
+  }
+  throw new Error("Invalid SignedBlockBoundWitnessWithStorageMetaish format");
+});
+UnsignedBoundWitnessZod.safeExtend(BlockBoundWitnessFieldsZod.shape).safeExtend(BlockBoundWitnessMetaZod.shape);
 tuple([
   BlockBoundWitnessZod,
   array$1(PayloadZodLoose)
@@ -73787,6 +74010,7 @@ var SignedHydratedBlockZod = tuple([
   SignedBlockBoundWitnessZod,
   array$1(PayloadZodLoose)
 ]);
+var isSignedHydratedBlock = zodIsFactory(SignedHydratedBlockZod);
 tuple([
   SignedBlockBoundWitnessZod,
   array$1(PayloadZodLoose)
@@ -73795,11 +74019,20 @@ var SignedHydratedBlockWithHashMetaZod = tuple([
   WithHashMetaZod(SignedBlockBoundWitnessZod),
   array$1(WithHashMetaZod(PayloadZodLoose))
 ]);
+tuple([
+  union$1([WithHashMetaZod(SignedBlockBoundWitnessZod)]),
+  array$1(WithHashMetaZod(PayloadZodLoose))
+]);
+var isSignedHydratedBlockWithHashMeta = zodIsFactory(SignedHydratedBlockWithHashMetaZod);
 var asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, "asSignedHydratedBlockWithHashMeta");
 tuple([
   WithStorageMetaZod(SignedBlockBoundWitnessZod),
   array$1(WithStorageMetaZod(PayloadZodLoose))
 ]);
+tuple([
+  union$1([WithStorageMetaZod(SignedBlockBoundWitnessZod)]),
+  array$1(WithStorageMetaZod(PayloadZodLoose))
+]);
 var AttoZod = bigint$1();
 var JsonToAttoZod = JsonToBigIntZod.transform((v) => asAttoXL1(v));
 var AttoToJsonZod = BigIntToJsonZod;
@@ -73890,6 +74123,28 @@ tuple([
   WithStorageMetaZod(SignedTransactionBoundWitnessZod),
   array$1(WithStorageMetaZod(PayloadZodLoose))
 ]);
+var WithHashMetaishZod = PayloadZodLoose.transform(async (data) => {
+  if (isAnyPayload(data)) {
+    if (isHashMeta(data)) {
+      return data;
+    }
+    return await PayloadBuilder.addHashMeta(data);
+  }
+  throw new Error("Invalid WithHashMetaish format");
+});
+var toWithHashMeta = zodToAsyncFactory(
+  WithHashMetaishZod,
+  "toWithHashMeta"
+);
+PayloadZodLoose.transform(async (data) => {
+  if (isAnyPayload(data)) {
+    if (isStorageMeta(data)) {
+      return data;
+    }
+    return await PayloadBuilder.addStorageMeta(data);
+  }
+  throw new Error("Invalid WithStorageMetaish format");
+});
 var CaveatTypesZod = _enum$1(["chain", "expiration", "filteredResponse", "rateLimit", "restrictReturnedAccounts"]);
 var CaveatsZod = object$3({
   type: CaveatTypesZod,
@@ -365289,6 +365544,19 @@ var JsonRpcTimeSyncViewerMethods = class {
     super(transport);
   }
 });
+async function fixSignedHydratedBlockWithHashMeta(block) {
+  if (isSignedHydratedBlockWithHashMeta(block)) {
+    return block;
+  }
+  if (isSignedHydratedBlock(block)) {
+    return [
+      await toWithHashMeta(block[0], true),
+      await Promise.all(block[1].map((p) => toWithHashMeta(p, true)))
+    ];
+  }
+  throw new Error("Invalid block format");
+}
+__name$5(fixSignedHydratedBlockWithHashMeta, "fixSignedHydratedBlockWithHashMeta");
 var JsonRpcXyoViewer = class {
   static {
     __name$5(this, "JsonRpcXyoViewer");
@@ -365343,20 +365611,22 @@ var JsonRpcXyoViewer = class {
     throw new Error("Method not implemented.");
   }
   async blockByHash(hash) {
-    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByHash", [
+    const returned = await this.transport.sendRequest("xyoViewer_blockByHash", [
       hash
-    ])) ?? null;
+    ]);
+    return returned === null ? null : fixSignedHydratedBlockWithHashMeta(returned);
   }
   async blockByNumber(blockNumber) {
-    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByNumber", [
+    const returned = asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_blockByNumber", [
       blockNumber
     ])) ?? null;
+    return returned === null ? null : fixSignedHydratedBlockWithHashMeta(returned);
   }
   async blocksByHash(hash, limit) {
-    return (await this.transport.sendRequest("xyoViewer_blocksByHash", [
+    return await Promise.all((await this.transport.sendRequest("xyoViewer_blocksByHash", [
       hash,
       limit
-    ])).map((b) => asSignedHydratedBlockWithHashMeta(b, true));
+    ])).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async chainId() {
     return await this.transport.sendRequest("xyoViewer_chainId");
@@ -365367,7 +365637,8 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async currentBlock() {
-    return asSignedHydratedBlockWithHashMeta(await this.transport.sendRequest("xyoViewer_currentBlock"), true);
+    const result = await this.transport.sendRequest("xyoViewer_currentBlock");
+    return fixSignedHydratedBlockWithHashMeta(result);
   }
   async currentBlockHash() {
     return await this.transport.sendRequest("xyoViewer_currentBlockHash");
@@ -376153,7 +376424,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined("1.16.24") ? "1.16.24" : "unknown";
+var version = isDefined("1.16.25") ? "1.16.25" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-cli",
-  "version": "1.16.25",
+  "version": "1.16.26",
   "description": "XYO Layer One CLI",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -62,11 +62,11 @@
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@xylabs/sdk-js": "~5.0.42",
-    "@xylabs/telemetry": "~5.0.42",
+    "@xylabs/sdk-js": "~5.0.46",
+    "@xylabs/telemetry": "~5.0.46",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.42",
+    "@xylabs/vitest-extended": "~5.0.46",
     "@xyo-network/account-model": "~5.2.10",
     "@xyo-network/archivist-lmdb": "~5.2.10",
     "@xyo-network/archivist-memory": "~5.2.10",
@@ -75,8 +75,8 @@
     "@xyo-network/payload-model": "~5.2.10",
     "@xyo-network/wallet": "~5.2.10",
     "@xyo-network/wallet-model": "~5.2.10",
-    "@xyo-network/xl1-cli-lib": "~1.16.25",
-    "@xyo-network/xl1-protocol": "~1.14.13",
+    "@xyo-network/xl1-cli-lib": "~1.16.26",
+    "@xyo-network/xl1-protocol": "~1.14.15",
     "async-mutex": "~0.5.0",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
@@ -88,7 +88,7 @@
     "vitest": "~4.0.13",
     "vitest-mock-extended": "~3.1.0",
     "yargs": "~18.0.0",
-    "zod": "~4.1.12"
+    "zod": "~4.1.13"
   },
   "peerDependencies": {
     "typescript": "~5"