fullstacked 0.12.1-1359 → 0.12.1-1366

package/fullstacked_modules/zod/v4/classic/schemas.d.ts

@@ -1,9 +1,6 @@
 import * as core from "../core/index.js";
 import { util } from "../core/index.js";
 import * as parse from "./parse.js";
-export interface RefinementCtx<T = unknown> extends core.ParsePayload<T> {
-    addIssue(arg: string | core.$ZodRawIssue | Partial<core.$ZodIssueCustom>): void;
-}
 export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     def: Internals["def"];
     type: Internals["def"]["type"];
@@ -24,22 +21,29 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
+    encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;
+    decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
+    encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;
+    decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
+    safeEncode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.input<this>>;
+    safeDecode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.output<this>>;
+    safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.input<this>>>;
+    safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
-    /** @deprecated Use `.check()` instead. */
-    superRefine(refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>): this;
+    superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>): this;
     overwrite(fn: (x: core.output<this>) => core.output<this>): this;
     optional(): ZodOptional<this>;
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
     nullable(): ZodNullable<this>;
     nullish(): ZodOptional<ZodNullable<this>>;
-    default(def: core.output<this>): ZodDefault<this>;
+    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
     default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
     prefault(def: () => core.input<this>): ZodPrefault<this>;
     prefault(def: core.input<this>): ZodPrefault<this>;
     array(): ZodArray<this>;
     or<T extends core.SomeType>(option: T): ZodUnion<[this, T]>;
     and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
+    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
     catch(def: core.output<this>): ZodCatch<this>;
     catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;
     pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.output<this>>): ZodPipe<this, T>;
@@ -178,6 +182,7 @@ export interface ZodURL extends ZodStringFormat<"url"> {
 }
 export declare const ZodURL: core.$constructor<ZodURL>;
 export declare function url(params?: string | core.$ZodURLParams): ZodURL;
+export declare function httpUrl(params?: string | Omit<core.$ZodURLParams, "protocol" | "hostname">): ZodURL;
 export interface ZodEmoji extends ZodStringFormat<"emoji"> {
     _zod: core.$ZodEmojiInternals;
 }
@@ -258,6 +263,11 @@ export interface ZodCustomStringFormat<Format extends string = string> extends Z
 }
 export declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
+export declare function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hex">;
+export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
 export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals> extends _ZodType<Internals> {
     gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
     /** Identical to .min() */
@@ -398,7 +408,10 @@ export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodT
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
 export declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
-export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<Exclude<keyof T["_zod"]["output"], symbol>>;
+export declare function keyof<T extends ZodObject>(schema: T): ZodEnum<util.KeysEnum<T["_zod"]["output"]>>;
+export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
+};
 export interface ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
@@ -414,19 +427,10 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
     strict(): ZodObject<Shape, core.$strict>;
     /** This is the default behavior. This method call is likely unnecessary. */
     strip(): ZodObject<Shape, core.$strip>;
-    extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;
+    safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodObject<util.Extend<Shape, U>, Config>;
     /**
-     * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
-     *
-     * ```ts
-     * const A = z.object({ a: z.string() });
-     * const B = z.object({ b: z.number() });
-     *
-     * const C = z.object({
-     *    ...A.shape,
-     *    ...B.shape
-     * });
-     * ```
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
      */
     merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
     pick<M extends util.Mask<keyof Shape>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
@@ -453,11 +457,12 @@ export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$Zo
 }
 export declare const ZodUnion: core.$constructor<ZodUnion>;
 export declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T>;
-export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[]> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options> {
-    _zod: core.$ZodDiscriminatedUnionInternals<Options>;
+export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options, Disc> {
+    _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
+    def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]]>(discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
 }
 export declare const ZodIntersection: core.$constructor<ZodIntersection>;
@@ -484,7 +489,6 @@ export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;
 export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {
     min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
-    /** */
     nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
     max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
     size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
@@ -581,7 +585,17 @@ export interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core
 }
 export declare const ZodPipe: core.$constructor<ZodPipe>;
 export declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B>;
+export interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends ZodPipe<A, B>, core.$ZodCodec<A, B> {
+    _zod: core.$ZodCodecInternals<A, B>;
+    def: core.$ZodCodecDef<A, B>;
+}
+export declare const ZodCodec: core.$constructor<ZodCodec>;
+export declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+}): ZodCodec<A, B>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
+    unwrap(): T;
 }
 export declare const ZodReadonly: core.$constructor<ZodReadonly>;
 export declare function readonly<T extends core.SomeType>(innerType: T): ZodReadonly<T>;
@@ -599,17 +613,46 @@ export interface ZodPromise<T extends core.SomeType = core.$ZodType> extends _Zo
 }
 export declare const ZodPromise: core.$constructor<ZodPromise>;
 export declare function promise<T extends core.SomeType>(innerType: T): ZodPromise<T>;
+export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut> extends _ZodType<core.$ZodFunctionInternals<Args, Returns>>, core.$ZodFunction<Args, Returns> {
+    _def: core.$ZodFunctionDef<Args, Returns>;
+    _input: core.$InferInnerFunctionType<Args, Returns>;
+    _output: core.$InferOuterFunctionType<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<core.$ZodTuple<Items, Rest>, Returns>;
+    input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns>;
+    input(...args: any[]): ZodFunction<any, Returns>;
+    output<NewReturns extends core.$ZodType>(output: NewReturns): ZodFunction<Args, NewReturns>;
+}
+export declare const ZodFunction: core.$constructor<ZodFunction>;
+export declare function _function(): ZodFunction;
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
+    input: In;
+}): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+    input: In;
+    output: Out;
+}): ZodFunction<ZodTuple<In, null>, Out>;
+export declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn>(params: {
+    input: In;
+}): ZodFunction<In, core.$ZodFunctionOut>;
+export declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+    output: Out;
+}): ZodFunction<core.$ZodFunctionIn, Out>;
+export declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodType = core.$ZodType>(params?: {
+    input: In;
+    output: Out;
+}): ZodFunction<In, Out>;
+export { _function as function };
 export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
-export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
-export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodPipe<ZodString, ZodTransform<boolean, string>>, ZodBoolean>;
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
 type _ZodJSONSchema = ZodUnion<[
     ZodString,
     ZodNumber,
@@ -627,4 +670,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;

package/fullstacked_modules/zod/v4/classic/schemas.js

@@ -6,18 +6,16 @@ import * as parse from "./parse.js";
 export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
     core.$ZodType.init(inst, def);
     inst.def = def;
+    inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
     // base methods
     inst.check = (...checks) => {
-        return inst.clone({
-            ...def,
+        return inst.clone(util.mergeDefs(def, {
             checks: [
                 ...(def.checks ?? []),
                 ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
-        }
-        // { parent: true }
-        );
+        }));
     };
     inst.clone = (def, params) => core.clone(inst, def, params);
     inst.brand = () => inst;
@@ -31,6 +29,15 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
     inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
     inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
     inst.spa = inst.safeParseAsync;
+    // encoding/decoding
+    inst.encode = (data, params) => parse.encode(inst, data, params);
+    inst.decode = (data, params) => parse.decode(inst, data, params);
+    inst.encodeAsync = async (data, params) => parse.encodeAsync(inst, data, params);
+    inst.decodeAsync = async (data, params) => parse.decodeAsync(inst, data, params);
+    inst.safeEncode = (data, params) => parse.safeEncode(inst, data, params);
+    inst.safeDecode = (data, params) => parse.safeDecode(inst, data, params);
+    inst.safeEncodeAsync = async (data, params) => parse.safeEncodeAsync(inst, data, params);
+    inst.safeDecodeAsync = async (data, params) => parse.safeDecodeAsync(inst, data, params);
     // refinements
     inst.refine = (check, params) => inst.check(refine(check, params));
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
@@ -182,6 +189,13 @@ export const ZodURL = /*@__PURE__*/ core.$constructor("ZodURL", (inst, def) => {
 export function url(params) {
     return core._url(ZodURL, params);
 }
+export function httpUrl(params) {
+    return core._url(ZodURL, {
+        protocol: /^https?$/,
+        hostname: core.regexes.domain,
+        ...util.normalizeParams(params),
+    });
+}
 export const ZodEmoji = /*@__PURE__*/ core.$constructor("ZodEmoji", (inst, def) => {
     // ZodStringFormat.init(inst, def);
     core.$ZodEmoji.init(inst, def);
@@ -308,6 +322,20 @@ export const ZodCustomStringFormat = /*@__PURE__*/ core.$constructor("ZodCustomS
 export function stringFormat(format, fnOrRegex, _params = {}) {
     return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
+export function hostname(_params) {
+    return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
+}
+export function hex(_params) {
+    return core._stringFormat(ZodCustomStringFormat, "hex", core.regexes.hex, _params);
+}
+export function hash(alg, params) {
+    const enc = params?.enc ?? "hex";
+    const format = `${alg}_${enc}`;
+    const regex = core.regexes[format];
+    if (!regex)
+        throw new Error(`Unrecognized hash format: ${format}`);
+    return core._stringFormat(ZodCustomStringFormat, format, regex, params);
+}
 export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => {
     core.$ZodNumber.init(inst, def);
     ZodType.init(inst, def);
@@ -481,22 +509,26 @@ export function array(element, params) {
 // .keyof
 export function keyof(schema) {
     const shape = schema._zod.def.shape;
-    return literal(Object.keys(shape));
+    return _enum(Object.keys(shape));
 }
 export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => {
-    core.$ZodObject.init(inst, def);
+    core.$ZodObjectJIT.init(inst, def);
     ZodType.init(inst, def);
-    util.defineLazy(inst, "shape", () => def.shape);
+    util.defineLazy(inst, "shape", () => {
+        return def.shape;
+    });
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });
     inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-    // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() });
     inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
     inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
     inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
     inst.extend = (incoming) => {
         return util.extend(inst, incoming);
     };
+    inst.safeExtend = (incoming) => {
+        return util.safeExtend(inst, incoming);
+    };
     inst.merge = (other) => util.merge(inst, other);
     inst.pick = (mask) => util.pick(inst, mask);
     inst.omit = (mask) => util.omit(inst, mask);
@@ -506,10 +538,7 @@ export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def
 export function object(shape, params) {
     const def = {
         type: "object",
-        get shape() {
-            util.assignProp(this, "shape", { ...shape });
-            return this.shape;
-        },
+        shape: shape ?? {},
         ...util.normalizeParams(params),
     };
     return new ZodObject(def);
@@ -518,10 +547,7 @@ export function object(shape, params) {
 export function strictObject(shape, params) {
     return new ZodObject({
         type: "object",
-        get shape() {
-            util.assignProp(this, "shape", { ...shape });
-            return this.shape;
-        },
+        shape,
         catchall: never(),
         ...util.normalizeParams(params),
     });
@@ -530,10 +556,7 @@ export function strictObject(shape, params) {
 export function looseObject(shape, params) {
     return new ZodObject({
         type: "object",
-        get shape() {
-            util.assignProp(this, "shape", { ...shape });
-            return this.shape;
-        },
+        shape,
         catchall: unknown(),
         ...util.normalizeParams(params),
     });
@@ -609,9 +632,11 @@ export function record(keyType, valueType, params) {
 }
 // type alksjf = core.output<core.$ZodRecordKey>;
 export function partialRecord(keyType, valueType, params) {
+    const k = core.clone(keyType);
+    k._zod.values = undefined;
     return new ZodRecord({
         type: "record",
-        keyType: union([keyType, never()]),
+        keyType: k,
         valueType: valueType,
         ...util.normalizeParams(params),
     });
@@ -741,6 +766,9 @@ export const ZodTransform = /*@__PURE__*/ core.$constructor("ZodTransform", (ins
     core.$ZodTransform.init(inst, def);
     ZodType.init(inst, def);
     inst._zod.parse = (payload, _ctx) => {
+        if (_ctx.direction === "backward") {
+            throw new core.$ZodEncodeError(inst.constructor.name);
+        }
         payload.addIssue = (issue) => {
             if (typeof issue === "string") {
                 payload.issues.push(util.issue(issue, payload.value, def));
@@ -753,7 +781,7 @@ export const ZodTransform = /*@__PURE__*/ core.$constructor("ZodTransform", (ins
                 _issue.code ?? (_issue.code = "custom");
                 _issue.input ?? (_issue.input = payload.value);
                 _issue.inst ?? (_issue.inst = inst);
-                _issue.continue ?? (_issue.continue = true);
+                // _issue.continue ??= true;
                 payload.issues.push(util.issue(_issue));
             }
         };
@@ -811,7 +839,7 @@ export function _default(innerType, defaultValue) {
         type: "default",
         innerType: innerType,
         get defaultValue() {
-            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+            return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
         },
     });
 }
@@ -825,7 +853,7 @@ export function prefault(innerType, defaultValue) {
         type: "prefault",
         innerType: innerType,
         get defaultValue() {
-            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+            return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
         },
     });
 }
@@ -887,9 +915,23 @@ export function pipe(in_, out) {
         // ...util.normalizeParams(params),
     });
 }
+export const ZodCodec = /*@__PURE__*/ core.$constructor("ZodCodec", (inst, def) => {
+    ZodPipe.init(inst, def);
+    core.$ZodCodec.init(inst, def);
+});
+export function codec(in_, out, params) {
+    return new ZodCodec({
+        type: "pipe",
+        in: in_,
+        out: out,
+        transform: params.decode,
+        reverseTransform: params.encode,
+    });
+}
 export const ZodReadonly = /*@__PURE__*/ core.$constructor("ZodReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
 export function readonly(innerType) {
     return new ZodReadonly({
@@ -930,6 +972,18 @@ export function promise(innerType) {
         innerType: innerType,
     });
 }
+export const ZodFunction = /*@__PURE__*/ core.$constructor("ZodFunction", (inst, def) => {
+    core.$ZodFunction.init(inst, def);
+    ZodType.init(inst, def);
+});
+export function _function(params) {
+    return new ZodFunction({
+        type: "function",
+        input: Array.isArray(params?.input) ? tuple(params?.input) : (params?.input ?? array(unknown())),
+        output: params?.output ?? unknown(),
+    });
+}
+export { _function as function };
 export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def) => {
     core.$ZodCustom.init(inst, def);
     ZodType.init(inst, def);
@@ -951,26 +1005,7 @@ export function refine(fn, _params = {}) {
 }
 // superRefine
 export function superRefine(fn) {
-    const ch = check((payload) => {
-        payload.addIssue = (issue) => {
-            if (typeof issue === "string") {
-                payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
-            }
-            else {
-                // for Zod 3 backwards compatibility
-                const _issue = issue;
-                if (_issue.fatal)
-                    _issue.continue = false;
-                _issue.code ?? (_issue.code = "custom");
-                _issue.input ?? (_issue.input = payload.value);
-                _issue.inst ?? (_issue.inst = ch);
-                _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
-                payload.issues.push(util.issue(_issue));
-            }
-        };
-        return fn(payload.value, payload);
-    });
-    return ch;
+    return core._superRefine(fn);
 }
 function _instanceof(cls, params = {
     error: `Input not instance of ${cls.name}`,
@@ -988,10 +1023,9 @@ function _instanceof(cls, params = {
 export { _instanceof as instanceof };
 // stringbool
 export const stringbool = (...args) => core._stringbool({
-    Pipe: ZodPipe,
+    Codec: ZodCodec,
     Boolean: ZodBoolean,
     String: ZodString,
-    Transform: ZodTransform,
 }, ...args);
 export function json(params) {
     const jsonSchema = lazy(() => {

package/fullstacked_modules/zod/v4/core/api.cjs

@@ -135,6 +135,8 @@ exports._lazy = _lazy;
 exports._promise = _promise;
 exports._custom = _custom;
 exports._refine = _refine;
+exports._superRefine = _superRefine;
+exports._check = _check;
 exports._stringbool = _stringbool;
 exports._stringFormat = _stringFormat;
 const checks = __importStar(require("./checks.cjs"));
@@ -880,7 +882,7 @@ function _default(Class, innerType, defaultValue) {
         type: "default",
         innerType,
         get defaultValue() {
-            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+            return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
         },
     });
 }
@@ -947,13 +949,6 @@ function _custom(Class, fn, _params) {
     });
     return schema;
 }
-// export function _refine<T>(
-//   Class: util.SchemaClass<schemas.$ZodCustom>,
-//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
-//   _params: string | $ZodCustomParams = {}
-// ): checks.$ZodCheck<T> {
-//   return _custom(Class, fn, _params);
-// }
 // same as _custom but defaults to abort:false
 function _refine(Class, fn, _params) {
     const schema = new Class({
@@ -964,6 +959,36 @@ function _refine(Class, fn, _params) {
     });
     return schema;
 }
+function _superRefine(fn) {
+    const ch = _check((payload) => {
+        payload.addIssue = (issue) => {
+            if (typeof issue === "string") {
+                payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
+            }
+            else {
+                // for Zod 3 backwards compatibility
+                const _issue = issue;
+                if (_issue.fatal)
+                    _issue.continue = false;
+                _issue.code ?? (_issue.code = "custom");
+                _issue.input ?? (_issue.input = payload.value);
+                _issue.inst ?? (_issue.inst = ch);
+                _issue.continue ?? (_issue.continue = !ch._zod.def.abort); // abort is always undefined, so this is always true...
+                payload.issues.push(util.issue(_issue));
+            }
+        };
+        return fn(payload.value, payload);
+    });
+    return ch;
+}
+function _check(fn, params) {
+    const ch = new checks.$ZodCheck({
+        check: "custom",
+        ...util.normalizeParams(params),
+    });
+    ch._zod.check = fn;
+    return ch;
+}
 function _stringbool(Classes, _params) {
     const params = util.normalizeParams(_params);
     let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -974,13 +999,16 @@ function _stringbool(Classes, _params) {
     }
     const truthySet = new Set(truthyArray);
     const falsySet = new Set(falsyArray);
-    const _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
+    const _Codec = Classes.Codec ?? schemas.$ZodCodec;
     const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
     const _String = Classes.String ?? schemas.$ZodString;
-    const _Transform = Classes.Transform ?? schemas.$ZodTransform;
-    const tx = new _Transform({
-        type: "transform",
-        transform: (input, payload) => {
+    const stringSchema = new _String({ type: "string", error: params.error });
+    const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
+    const codec = new _Codec({
+        type: "pipe",
+        in: stringSchema,
+        out: booleanSchema,
+        transform: ((input, payload) => {
             let data = input;
             if (params.case !== "sensitive")
                 data = data.toLowerCase();
@@ -996,30 +1024,23 @@ function _stringbool(Classes, _params) {
                     expected: "stringbool",
                     values: [...truthySet, ...falsySet],
                     input: payload.value,
-                    inst: tx,
+                    inst: codec,
+                    continue: false,
                 });
                 return {};
             }
-        },
-        error: params.error,
-    });
-    // params.error;
-    const innerPipe = new _Pipe({
-        type: "pipe",
-        in: new _String({ type: "string", error: params.error }),
-        out: tx,
-        error: params.error,
-    });
-    const outerPipe = new _Pipe({
-        type: "pipe",
-        in: innerPipe,
-        out: new _Boolean({
-            type: "boolean",
-            error: params.error,
+        }),
+        reverseTransform: ((input, _payload) => {
+            if (input === true) {
+                return truthyArray[0] || "true";
+            }
+            else {
+                return falsyArray[0] || "false";
+            }
         }),
         error: params.error,
     });
-    return outerPipe;
+    return codec;
 }
 function _stringFormat(Class, format, fnOrRegex, _params = {}) {
     const params = util.normalizeParams(_params);