@suveren/gateway 0.39.0 → 0.40.0

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

@@ -0,0 +1,45 @@
+import type * as core from "../core/index.js";
+import { clone, mergeDefs } from "../core/util.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+
+// Co-located with the functions: a type and a value can only share a name from one module.
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+
+/** Appends a pipe's own checks to the side that replaces it, mirroring how `.check()` clones. */
+function withChecks(side: core.$ZodType, checks: core.$ZodTypeDef["checks"]): core.$ZodType {
+  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: core.$ZodPipeDef): core.$ZodType {
+  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: core.$ZodPipeDef): core.$ZodType {
+  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<T extends core.$ZodType>(schema: T): schemas.ZodType<core.input<T>, core.input<T>> {
+  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),
+  }) as 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 function output<T extends core.$ZodType>(schema: T): schemas.ZodType<core.output<T>, core.output<T>> {
+  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),
+  }) as schemas.ZodType<core.output<T>, core.output<T>>;
+}

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

@@ -1,5 +1,5 @@
 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/src/v4/classic/iso.ts

@@ -1,90 +1,20 @@
 import * as core from "../core/index.js";
-import * as schemas from "./schemas.js";
+import { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
 
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-//////////                          //////////
-//////////      ZodISODateTime      //////////
-//////////                          //////////
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-
-export interface ZodISODateTime extends schemas.ZodStringFormat {
-  _zod: core.$ZodISODateTimeInternals;
-}
-export const ZodISODateTime: core.$constructor<ZodISODateTime> = /*@__PURE__*/ core.$constructor(
-  "ZodISODateTime",
-  (inst, def) => {
-    core.$ZodISODateTime.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-  }
-);
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime } from "./schemas.js";
 
 export function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime {
   return core._isoDateTime(ZodISODateTime, params);
 }
 
-//////////////////////////////////////////
-//////////////////////////////////////////
-//////////                      //////////
-//////////      ZodISODate      //////////
-//////////                      //////////
-//////////////////////////////////////////
-//////////////////////////////////////////
-
-export interface ZodISODate extends schemas.ZodStringFormat {
-  _zod: core.$ZodISODateInternals;
-}
-export const ZodISODate: core.$constructor<ZodISODate> = /*@__PURE__*/ core.$constructor("ZodISODate", (inst, def) => {
-  core.$ZodISODate.init(inst, def);
-  schemas.ZodStringFormat.init(inst, def);
-});
-
 export function date(params?: string | core.$ZodISODateParams): ZodISODate {
   return core._isoDate(ZodISODate, params);
 }
 
-// ZodISOTime
-
-//////////////////////////////////////////
-//////////////////////////////////////////
-//////////                      //////////
-//////////      ZodISOTime      //////////
-//////////                      //////////
-//////////////////////////////////////////
-//////////////////////////////////////////
-
-export interface ZodISOTime extends schemas.ZodStringFormat {
-  _zod: core.$ZodISOTimeInternals;
-}
-export const ZodISOTime: core.$constructor<ZodISOTime> = /*@__PURE__*/ core.$constructor("ZodISOTime", (inst, def) => {
-  core.$ZodISOTime.init(inst, def);
-  schemas.ZodStringFormat.init(inst, def);
-});
-
 export function time(params?: string | core.$ZodISOTimeParams): ZodISOTime {
   return core._isoTime(ZodISOTime, params);
 }
 
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-//////////                          //////////
-//////////      ZodISODuration      //////////
-//////////                          //////////
-//////////////////////////////////////////////
-//////////////////////////////////////////////
-
-export interface ZodISODuration extends schemas.ZodStringFormat {
-  _zod: core.$ZodISODurationInternals;
-}
-export const ZodISODuration: core.$constructor<ZodISODuration> = /*@__PURE__*/ core.$constructor(
-  "ZodISODuration",
-  (inst, def) => {
-    core.$ZodISODuration.init(inst, def);
-    schemas.ZodStringFormat.init(inst, def);
-  }
-);
-
 export function duration(params?: string | core.$ZodISODurationParams): ZodISODuration {
   return core._isoDuration(ZodISODuration, params);
 }

package/node_modules/zod/src/v4/classic/parse.ts

@@ -10,14 +10,14 @@ export const parse: <T extends core.$ZodType>(
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>,
   _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
-) => core.output<T> = /* @__PURE__ */ core._parse(ZodRealError) as any;
+) => core.output<T> = /* @__PURE__ */ core._parse(ZodRealError);
 
 export const parseAsync: <T extends core.$ZodType>(
   schema: T,
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>,
   _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
-) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync(ZodRealError) as any;
+) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync(ZodRealError);
 
 export const safeParse: <T extends core.$ZodType>(
   schema: T,
@@ -31,3 +31,58 @@ export const safeParseAsync: <T extends core.$ZodType>(
   value: unknown,
   _ctx?: core.ParseContext<core.$ZodIssue>
 ) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeParseAsync(ZodRealError) as any;
+
+export { validate, validateAsync } from "../core/index.js";
+
+// Codec functions
+export const encode: <T extends core.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => core.input<T> = /* @__PURE__ */ core._encode(ZodRealError);
+
+export const decode: <T extends core.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => core.output<T> = /* @__PURE__ */ core._decode(ZodRealError);
+
+export const encodeAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => Promise<core.input<T>> = /* @__PURE__ */ core._encodeAsync(ZodRealError);
+
+export const decodeAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => Promise<core.output<T>> = /* @__PURE__ */ core._decodeAsync(ZodRealError);
+
+export const safeEncode: <T extends core.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => ZodSafeParseResult<core.input<T>> = /* @__PURE__ */ core._safeEncode(ZodRealError) as any;
+
+export const safeDecode: <T extends core.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => ZodSafeParseResult<core.output<T>> = /* @__PURE__ */ core._safeDecode(ZodRealError) as any;
+
+export const safeEncodeAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => Promise<ZodSafeParseResult<core.input<T>>> = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError) as any;
+
+export const safeDecodeAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError) as any;