@openclaw/slack 2026.9.4 → 2026.9.5

package/node_modules/zod/v4/classic/from-json-schema.js

@@ -1,4 +1,5 @@
 import { globalRegistry } from "../core/registries.js";
+import { assignProp, isPlainObject } from "../core/util.js";
 import * as _checks from "./checks.js";
 import * as _iso from "./iso.js";
 import * as _schemas from "./schemas.js";
@@ -94,6 +95,14 @@ function detectVersion(schema, defaultTarget) {
     // Use defaultTarget if provided, otherwise default to draft-2020-12
     return defaultTarget ?? "draft-2020-12";
 }
+// Positional schemas constrain the elements that are present; only minItems makes them required.
+function applyMinItems(items, minItems) {
+    return items.map((item, index) => (index < minItems ? item : item.optional()));
+}
+// Inverse of the encoding applied to $ref pointer segments in to-json-schema.ts. Per RFC 6901 the `~1` replacement must run before `~0`.
+function decodeJSONPointerSegment(segment) {
+    return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
 function resolveRef(ref, ctx) {
     if (!ref.startsWith("#")) {
         throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
@@ -105,7 +114,7 @@ function resolveRef(ref, ctx) {
     }
     const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
     if (path[0] === defsKey) {
-        const key = path[1];
+        const key = path[1] === undefined ? undefined : decodeJSONPointerSegment(path[1]);
         if (!key || !ctx.defs[key]) {
             throw new Error(`Reference not found: ${ref}`);
         }
@@ -113,6 +122,47 @@ function resolveRef(ref, ctx) {
     }
     throw new Error(`Reference not found: ${ref}`);
 }
+/**
+ * Rejects every own key that fails `keySchema`, before `objectSchema` runs. The
+ * guard has to see the raw input: an object parse drops `__proto__` and can add
+ * keys from a property `default`, so its output is not the set of names the
+ * instance actually carried.
+ */
+function checkPropertyNames(objectSchema, keySchema) {
+    // An identity transform, not z.any(), so `toJSONSchema` reports the object on both the input and the output side of the pipe.
+    const guard = z
+        .transform((value) => value)
+        .check((payload) => {
+        const value = payload.value;
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return;
+        for (const key of Object.getOwnPropertyNames(value)) {
+            const result = keySchema.safeParse(key);
+            if (result.success)
+                continue;
+            payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: result.error.issues,
+                input: key,
+                path: [key],
+                continue: true,
+            });
+        }
+    });
+    return guard.pipe(objectSchema);
+}
+function getTupleRest(restSchema, ctx) {
+    if (restSchema === false) {
+        return undefined;
+    }
+    if (restSchema === undefined || restSchema === true) {
+        return z.any();
+    }
+    return convertSchema(restSchema, ctx);
+}
+// the RFC 3339 full-time keyword, narrower than `z.iso.time()`; local because sharing it via `timeSource` pins that builder into every bundle (+139 B gzipped on a mini `z.boolean()`)
+const fullTime = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
 function convertBaseSchema(schema, ctx) {
     // Handle unsupported features
     if (schema.not !== undefined) {
@@ -225,17 +275,20 @@ function convertBaseSchema(schema, ctx) {
                     stringSchema = stringSchema.check(z.uuid());
                 }
                 else if (format === "date-time") {
-                    stringSchema = stringSchema.check(z.iso.datetime());
+                    stringSchema = stringSchema.check(z.iso.datetime({ offset: true }));
                 }
                 else if (format === "date") {
                     stringSchema = stringSchema.check(z.iso.date());
                 }
                 else if (format === "time") {
-                    stringSchema = stringSchema.check(z.iso.time());
+                    stringSchema = stringSchema.check(z.regex(fullTime));
                 }
                 else if (format === "duration") {
                     stringSchema = stringSchema.check(z.iso.duration());
                 }
+                else if (format === "hostname") {
+                    stringSchema = stringSchema.check(z.hostname());
+                }
                 else if (format === "ipv4") {
                     stringSchema = stringSchema.check(z.ipv4());
                 }
@@ -260,6 +313,9 @@ function convertBaseSchema(schema, ctx) {
                 else if (format === "e164") {
                     stringSchema = stringSchema.check(z.e164());
                 }
+                else if (format === "credit_card") {
+                    stringSchema = stringSchema.check(z.creditCard());
+                }
                 else if (format === "jwt") {
                     stringSchema = stringSchema.check(z.jwt());
                 }
@@ -305,10 +361,11 @@ function convertBaseSchema(schema, ctx) {
         case "integer": {
             let numberSchema = type === "integer" ? z.number().int() : z.number();
             // Apply constraints
-            if (typeof schema.minimum === "number") {
+            // In draft-04, `exclusiveMinimum: true` makes the sibling `minimum` exclusive rather than an independent bound, so the inclusive `.min()` is skipped; emitting it too would be dominated by the exclusive check and report a second, weaker issue.
+            if (typeof schema.minimum === "number" && schema.exclusiveMinimum !== true) {
                 numberSchema = numberSchema.min(schema.minimum);
             }
-            if (typeof schema.maximum === "number") {
+            if (typeof schema.maximum === "number" && schema.exclusiveMaximum !== true) {
                 numberSchema = numberSchema.max(schema.maximum);
             }
             if (typeof schema.exclusiveMinimum === "number") {
@@ -341,33 +398,18 @@ function convertBaseSchema(schema, ctx) {
             const shape = {};
             const properties = schema.properties || {};
             const requiredSet = new Set(schema.required || []);
+            const additionalSchema = typeof schema.additionalProperties === "object"
+                ? convertSchema(schema.additionalProperties, ctx)
+                : undefined;
             // Convert properties - mark optional ones
             for (const [key, propSchema] of Object.entries(properties)) {
                 const propZodSchema = convertSchema(propSchema, ctx);
-                // If not in required array, make it optional
-                shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
-            }
-            // Handle propertyNames
-            if (schema.propertyNames) {
-                const keySchema = convertSchema(schema.propertyNames, ctx);
-                const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object"
-                    ? convertSchema(schema.additionalProperties, ctx)
-                    : z.any();
-                // Case A: No properties (pure record)
-                if (Object.keys(shape).length === 0) {
-                    zodSchema = z.record(keySchema, valueSchema);
-                    break;
-                }
-                // Case B: With properties (intersection of object and looseRecord)
-                const objectSchema = z.object(shape).passthrough();
-                const recordSchema = z.looseRecord(keySchema, valueSchema);
-                zodSchema = z.intersection(objectSchema, recordSchema);
-                break;
+                // If not in required array, make it optional. assignProp so a __proto__ key becomes an own property instead of hitting the inherited setter
+                assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
             }
             // Handle patternProperties
             if (schema.patternProperties) {
-                // patternProperties: keys matching pattern must satisfy corresponding schema
-                // Use loose records so non-matching keys pass through
+                // patternProperties: keys matching pattern must satisfy corresponding schema. Use loose records so non-matching keys pass through
                 const patternProps = schema.patternProperties;
                 const patternKeys = Object.keys(patternProps);
                 const looseRecords = [];
@@ -397,44 +439,72 @@ function convertBaseSchema(schema, ctx) {
                     }
                     zodSchema = result;
                 }
-                break;
-            }
-            // Handle additionalProperties
-            // In JSON Schema, additionalProperties defaults to true (allow any extra properties)
-            // In Zod, objects strip unknown keys by default, so we need to handle this explicitly
-            const objectSchema = z.object(shape);
-            if (schema.additionalProperties === false) {
-                // Strict mode - no extra properties allowed
-                zodSchema = objectSchema.strict();
-            }
-            else if (typeof schema.additionalProperties === "object") {
-                // Extra properties must match the specified schema
-                zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+                // When additionalProperties is false, reject keys that are neither defined in properties nor matched by any patternProperty.
+                if (schema.additionalProperties === false) {
+                    const propertyKeys = Object.keys(shape);
+                    const patterns = patternKeys.map((p) => new RegExp(p));
+                    const basePatternSchema = zodSchema;
+                    zodSchema = zodSchema.check((payload) => {
+                        if (!isPlainObject(payload.value))
+                            return;
+                        const unrecognized = [];
+                        for (const key of Object.keys(payload.value)) {
+                            if (propertyKeys.includes(key))
+                                continue;
+                            if (patterns.some((regex) => regex.test(key)))
+                                continue;
+                            unrecognized.push(key);
+                        }
+                        if (unrecognized.length) {
+                            payload.issues.push({
+                                code: "unrecognized_keys",
+                                keys: unrecognized,
+                                input: payload.value,
+                                inst: basePatternSchema,
+                            });
+                        }
+                    });
+                }
             }
             else {
-                // additionalProperties is true or undefined - allow any extra properties (passthrough)
-                zodSchema = objectSchema.passthrough();
+                // Handle additionalProperties. In JSON Schema, additionalProperties defaults to true (allow any extra properties). In Zod, objects strip unknown keys by default, so we need to handle this explicitly
+                const objectSchema = z.object(shape);
+                if (schema.additionalProperties === false) {
+                    // Strict mode - no extra properties allowed
+                    zodSchema = objectSchema.strict();
+                }
+                else if (additionalSchema) {
+                    // Extra properties must match the specified schema
+                    zodSchema = objectSchema.catchall(additionalSchema);
+                }
+                else {
+                    // additionalProperties is true or undefined - allow any extra properties (passthrough)
+                    zodSchema = objectSchema.passthrough();
+                }
+            }
+            // propertyNames constrains key *names* only, and says nothing about which keys are required or how their values validate. Layering it on top of the result keeps properties/patternProperties/additionalProperties composing underneath. `true` allows every name, so it needs no guard.
+            if (schema.propertyNames !== undefined && schema.propertyNames !== true) {
+                // Keys are always strings, so a propertyNames subschema that omits `type` still constrains them — without this it would convert to z.any().
+                const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === undefined
+                    ? { type: "string", ...schema.propertyNames }
+                    : schema.propertyNames;
+                zodSchema = checkPropertyNames(zodSchema, convertSchema(keyJSONSchema, ctx));
             }
             break;
         }
         case "array": {
-            // TODO: uniqueItems is not supported
-            // TODO: contains/minContains/maxContains are not supported
+            // TODO: uniqueItems and contains/minContains/maxContains are not supported
             // Check if this is a tuple (prefixItems or items as array)
             const prefixItems = schema.prefixItems;
             const items = schema.items;
             if (prefixItems && Array.isArray(prefixItems)) {
                 // Tuple with prefixItems (draft-2020-12)
+                const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
                 const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-                const rest = items && typeof items === "object" && !Array.isArray(items)
-                    ? convertSchema(items, ctx)
-                    : undefined;
-                if (rest) {
-                    zodSchema = z.tuple(tupleItems).rest(rest);
-                }
-                else {
-                    zodSchema = z.tuple(tupleItems);
-                }
+                const positionalItems = applyMinItems(tupleItems, minItems);
+                const rest = !Array.isArray(items) ? getTupleRest(items, ctx) : undefined;
+                const tupleSchema = z.tuple(positionalItems);
+                zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
                 // Apply minItems/maxItems constraints to tuples
                 if (typeof schema.minItems === "number") {
                     zodSchema = zodSchema.check(z.minLength(schema.minItems));
@@ -445,16 +515,12 @@ function convertBaseSchema(schema, ctx) {
             }
             else if (Array.isArray(items)) {
                 // Tuple with items array (draft-7)
+                const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
                 const tupleItems = items.map((item) => convertSchema(item, ctx));
-                const rest = schema.additionalItems && typeof schema.additionalItems === "object"
-                    ? convertSchema(schema.additionalItems, ctx)
-                    : undefined; // additionalItems: false means no rest, handled by default tuple behavior
-                if (rest) {
-                    zodSchema = z.tuple(tupleItems).rest(rest);
-                }
-                else {
-                    zodSchema = z.tuple(tupleItems);
-                }
+                const positionalItems = applyMinItems(tupleItems, minItems);
+                const rest = getTupleRest(schema.additionalItems, ctx);
+                const tupleSchema = z.tuple(positionalItems);
+                zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
                 // Apply minItems/maxItems constraints to tuples
                 if (typeof schema.minItems === "number") {
                     zodSchema = zodSchema.check(z.minLength(schema.minItems));
@@ -529,15 +595,11 @@ function convertSchema(schema, ctx) {
     if (schema.readOnly === true) {
         baseSchema = z.readonly(baseSchema);
     }
-    // Apply `default` so it wraps the fully-composed schema. This ensures
-    // `parse(undefined) -> default` works regardless of which branch of
-    // `convertBaseSchema` produced the inner schema (enum/const/not/typed/etc.).
+    // Apply `default` so it wraps the fully-composed schema. This ensures `parse(undefined) -> default` works regardless of which branch of `convertBaseSchema` produced the inner schema (enum/const/not/typed/etc.).
     if (schema.default !== undefined) {
         baseSchema = baseSchema.default(schema.default);
     }
-    // Collect non-description annotation metadata into the user-supplied
-    // registry. Description is handled separately below via `.describe()` to
-    // preserve the contract that `schema.description` reads from globalRegistry.
+    // Collect non-description annotation metadata into the user-supplied registry. Description is handled separately below via `.describe()` to preserve the contract that `schema.description` reads from globalRegistry.
     const extraMeta = {};
     const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
     for (const key of coreMetadataKeys) {
@@ -551,17 +613,19 @@ function convertSchema(schema, ctx) {
             extraMeta[key] = schema[key];
         }
     }
+    // `propertyNames` is enforced by a key guard, which `toJSONSchema` cannot infer, so the original keyword is carried as metadata to keep the round-trip lossless. Only where it was actually applied: on any other type it is inert, and on a `$ref` the metadata would land on the target every reference shares.
+    if (schema.propertyNames !== undefined && schema.type === "object" && schema.$ref === undefined) {
+        extraMeta.propertyNames = schema.propertyNames;
+    }
     for (const key of Object.keys(schema)) {
         if (!RECOGNIZED_KEYS.has(key)) {
-            extraMeta[key] = schema[key];
+            assignProp(extraMeta, key, schema[key]);
         }
     }
     if (Object.keys(extraMeta).length > 0) {
         ctx.registry.add(baseSchema, extraMeta);
     }
-    // Apply description last. `.describe()` clones the schema and sets
-    // `_zod.parent` on the clone, so registry lookups on the returned reference
-    // still resolve `extraMeta` via parent inheritance.
+    // Apply description last. `.describe()` clones the schema and sets `_zod.parent` on the clone, so registry lookups on the returned reference still resolve `extraMeta` via parent inheritance.
     if (schema.description) {
         baseSchema = baseSchema.describe(schema.description);
     }
@@ -574,10 +638,7 @@ export function fromJSONSchema(schema, params) {
     if (typeof schema === "boolean") {
         return schema ? z.any() : z.never();
     }
-    // Normalize input via a JSON round-trip. This guarantees the converter
-    // walks a plain, finite, JSON-valid object graph: cyclic inputs fail here,
-    // getter/Proxy-based properties are materialized into static values, and
-    // class instances collapse to plain objects.
+    // Normalize input via a JSON round-trip. This guarantees the converter walks a plain, finite, JSON-valid object graph: cyclic inputs fail here, getter/Proxy-based properties are materialized into static values, and class instances collapse to plain objects.
     let normalized;
     try {
         normalized = JSON.parse(JSON.stringify(schema));

package/node_modules/zod/v4/classic/in-out.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.input = input;
+exports.output = output;
+const util_js_1 = require("../core/util.cjs");
+const visit_js_1 = require("../core/visit.cjs");
+const schemas = __importStar(require("./schemas.cjs"));
+/** Appends a pipe's own checks to the side that replaces it, mirroring how `.check()` clones. */
+function withChecks(side, checks) {
+    if (!checks?.length)
+        return side;
+    const def = side._zod.def;
+    return (0, util_js_1.clone)(side, (0, util_js_1.mergeDefs)(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
+}
+/** The out side, carrying the pipe's own checks: those run against the decoded value, which is what `out` produces. */
+function outSide(def) {
+    return withChecks(def.out, def.checks);
+}
+/** The in side. `z.preprocess` pipes a transform into a schema, and a bare transform validates nothing, so the schema it feeds is the real input side — the resolution `toJSONSchema` already makes for this case. */
+function inSide(def) {
+    return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+function input(schema) {
+    return (0, visit_js_1.visit)(schema, {
+        pipe: (s) => inSide(s._zod.def),
+        // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+        default: (s, rewritten) => (rewritten ? schemas.optional(s._zod.def.innerType) : s),
+        // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+        catch: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+function output(schema) {
+    return (0, visit_js_1.visit)(schema, {
+        pipe: (s) => outSide(s._zod.def),
+        // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+        prefault: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}

package/node_modules/zod/v4/classic/in-out.d.cts

@@ -0,0 +1,8 @@
+import type * as core from "../core/index.cjs";
+import * as schemas from "./schemas.cjs";
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+export declare function input<T extends core.$ZodType>(schema: T): schemas.ZodType<core.input<T>, core.input<T>>;
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+export declare function output<T extends core.$ZodType>(schema: T): schemas.ZodType<core.output<T>, core.output<T>>;

package/node_modules/zod/v4/classic/in-out.d.ts

@@ -0,0 +1,8 @@
+import type * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+export declare function input<T extends core.$ZodType>(schema: T): schemas.ZodType<core.input<T>, core.input<T>>;
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+export declare function output<T extends core.$ZodType>(schema: T): schemas.ZodType<core.output<T>, core.output<T>>;

package/node_modules/zod/v4/classic/in-out.js

@@ -0,0 +1,36 @@
+import { clone, mergeDefs } from "../core/util.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+/** Appends a pipe's own checks to the side that replaces it, mirroring how `.check()` clones. */
+function withChecks(side, checks) {
+    if (!checks?.length)
+        return side;
+    const def = side._zod.def;
+    return clone(side, mergeDefs(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
+}
+/** The out side, carrying the pipe's own checks: those run against the decoded value, which is what `out` produces. */
+function outSide(def) {
+    return withChecks(def.out, def.checks);
+}
+/** The in side. `z.preprocess` pipes a transform into a schema, and a bare transform validates nothing, so the schema it feeds is the real input side — the resolution `toJSONSchema` already makes for this case. */
+function inSide(def) {
+    return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
+export function input(schema) {
+    return visit(schema, {
+        pipe: (s) => inSide(s._zod.def),
+        // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+        default: (s, rewritten) => (rewritten ? schemas.optional(s._zod.def.innerType) : s),
+        // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+        catch: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}
+/** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
+export function output(schema) {
+    return visit(schema, {
+        pipe: (s) => outSide(s._zod.def),
+        // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+        prefault: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}

package/node_modules/zod/v4/classic/index.cjs

@@ -26,8 +26,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.z = void 0;
+exports.default = exports.z = void 0;
 const z = __importStar(require("./external.cjs"));
 exports.z = z;
-__exportStar(require("./external.cjs"), exports);
 exports.default = z;
+__exportStar(require("./external.cjs"), exports);

package/node_modules/zod/v4/classic/index.d.cts

@@ -1,4 +1,3 @@
 import * as z from "./external.cjs";
-export { z };
 export * from "./external.cjs";
-export default z;
+export { z, z as default };

package/node_modules/zod/v4/classic/index.d.ts

@@ -1,4 +1,3 @@
 import * as z from "./external.js";
-export { z };
 export * from "./external.js";
-export default z;
+export { z, z as default };

package/node_modules/zod/v4/classic/index.js

@@ -1,4 +1,4 @@
 import * as z from "./external.js";
-export { z };
 export * from "./external.js";
-export default z;
+// See the note in `src/index.ts` — aliasing keeps the default export shakable.
+export { z, z as default };

package/node_modules/zod/v4/classic/iso.cjs

@@ -23,38 +23,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = void 0;
+exports.ZodISOTime = exports.ZodISODuration = exports.ZodISODateTime = exports.ZodISODate = void 0;
 exports.datetime = datetime;
 exports.date = date;
 exports.time = time;
 exports.duration = duration;
 const core = __importStar(require("../core/index.cjs"));
-const schemas = __importStar(require("./schemas.cjs"));
-exports.ZodISODateTime = core.$constructor("ZodISODateTime", (inst, def) => {
-    core.$ZodISODateTime.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
+const schemas_js_1 = require("./schemas.cjs");
+var schemas_js_2 = require("./schemas.cjs");
+Object.defineProperty(exports, "ZodISODate", { enumerable: true, get: function () { return schemas_js_2.ZodISODate; } });
+Object.defineProperty(exports, "ZodISODateTime", { enumerable: true, get: function () { return schemas_js_2.ZodISODateTime; } });
+Object.defineProperty(exports, "ZodISODuration", { enumerable: true, get: function () { return schemas_js_2.ZodISODuration; } });
+Object.defineProperty(exports, "ZodISOTime", { enumerable: true, get: function () { return schemas_js_2.ZodISOTime; } });
 function datetime(params) {
-    return core._isoDateTime(exports.ZodISODateTime, params);
+    return core._isoDateTime(schemas_js_1.ZodISODateTime, params);
 }
-exports.ZodISODate = core.$constructor("ZodISODate", (inst, def) => {
-    core.$ZodISODate.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 function date(params) {
-    return core._isoDate(exports.ZodISODate, params);
+    return core._isoDate(schemas_js_1.ZodISODate, params);
 }
-exports.ZodISOTime = core.$constructor("ZodISOTime", (inst, def) => {
-    core.$ZodISOTime.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 function time(params) {
-    return core._isoTime(exports.ZodISOTime, params);
+    return core._isoTime(schemas_js_1.ZodISOTime, params);
 }
-exports.ZodISODuration = core.$constructor("ZodISODuration", (inst, def) => {
-    core.$ZodISODuration.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 function duration(params) {
-    return core._isoDuration(exports.ZodISODuration, params);
+    return core._isoDuration(schemas_js_1.ZodISODuration, params);
 }

package/node_modules/zod/v4/classic/iso.d.cts

@@ -1,22 +1,7 @@
 import * as core from "../core/index.cjs";
-import * as schemas from "./schemas.cjs";
-export interface ZodISODateTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateTimeInternals;
-}
-export declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
+import { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.cjs";
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.cjs";
 export declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;
-export interface ZodISODate extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateInternals;
-}
-export declare const ZodISODate: core.$constructor<ZodISODate>;
 export declare function date(params?: string | core.$ZodISODateParams): ZodISODate;
-export interface ZodISOTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISOTimeInternals;
-}
-export declare const ZodISOTime: core.$constructor<ZodISOTime>;
 export declare function time(params?: string | core.$ZodISOTimeParams): ZodISOTime;
-export interface ZodISODuration extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODurationInternals;
-}
-export declare const ZodISODuration: core.$constructor<ZodISODuration>;
 export declare function duration(params?: string | core.$ZodISODurationParams): ZodISODuration;

package/node_modules/zod/v4/classic/iso.d.ts

@@ -1,22 +1,7 @@
 import * as core from "../core/index.js";
-import * as schemas from "./schemas.js";
-export interface ZodISODateTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateTimeInternals;
-}
-export declare const ZodISODateTime: core.$constructor<ZodISODateTime>;
+import { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
 export declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;
-export interface ZodISODate extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODateInternals;
-}
-export declare const ZodISODate: core.$constructor<ZodISODate>;
 export declare function date(params?: string | core.$ZodISODateParams): ZodISODate;
-export interface ZodISOTime extends schemas.ZodStringFormat {
-    _zod: core.$ZodISOTimeInternals;
-}
-export declare const ZodISOTime: core.$constructor<ZodISOTime>;
 export declare function time(params?: string | core.$ZodISOTimeParams): ZodISOTime;
-export interface ZodISODuration extends schemas.ZodStringFormat {
-    _zod: core.$ZodISODurationInternals;
-}
-export declare const ZodISODuration: core.$constructor<ZodISODuration>;
 export declare function duration(params?: string | core.$ZodISODurationParams): ZodISODuration;

package/node_modules/zod/v4/classic/iso.js

@@ -1,30 +1,15 @@
 import * as core from "../core/index.js";
-import * as schemas from "./schemas.js";
-export const ZodISODateTime = /*@__PURE__*/ core.$constructor("ZodISODateTime", (inst, def) => {
-    core.$ZodISODateTime.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
+import { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
 export function datetime(params) {
     return core._isoDateTime(ZodISODateTime, params);
 }
-export const ZodISODate = /*@__PURE__*/ core.$constructor("ZodISODate", (inst, def) => {
-    core.$ZodISODate.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 export function date(params) {
     return core._isoDate(ZodISODate, params);
 }
-export const ZodISOTime = /*@__PURE__*/ core.$constructor("ZodISOTime", (inst, def) => {
-    core.$ZodISOTime.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 export function time(params) {
     return core._isoTime(ZodISOTime, params);
 }
-export const ZodISODuration = /*@__PURE__*/ core.$constructor("ZodISODuration", (inst, def) => {
-    core.$ZodISODuration.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-});
 export function duration(params) {
     return core._isoDuration(ZodISODuration, params);
 }