@veryfront/ext-schema-zod 0.1.1284 → 0.1.1285

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAUV,eAAe,EAIhB,MAAM,6BAA6B,CAAC;AAqyBrC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAiGlD"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAUV,eAAe,EAIhB,MAAM,6BAA6B,CAAC;AAuzBrC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAiGlD"}

package/esm/adapter.js

@@ -14,7 +14,9 @@ import { Ajv2019 } from "ajv/dist/2019.js";
 import { Ajv2020 } from "ajv/dist/2020.js";
 import addFormatsModule from "ajv-formats";
 import { z } from "zod";
-import { isOptionalSchema, recordStaticJsonSchemaDefault, zodToJsonSchema } from "./json-schema.js";
+import { isOptionalSchema, recordStaticJsonSchemaDefault, recordTransparentSchemaInput, zodToJsonSchema, } from "./json-schema.js";
+import { preserveDeclaredObjectDataProperty } from "./object-data-properties.js";
+import { preserveUnionCheckDiagnostics } from "./union-diagnostics.js";
 // Deno exposes the CommonJS default as a callable value at runtime while the
 // package declaration describes the imported value as a module namespace.
 const addFormats = addFormatsModule;
@@ -24,6 +26,8 @@ function toZod(schema) {
 }
 /** Wrap a zod schema as an opaque Schema<T> with chainables routed through zod. */
 function wrap(zs) {
+    preserveDeclaredObjectDataProperty(zs);
+    preserveUnionCheckDiagnostics(zs);
     // The wrapper fakes the full Schema<T> surface; unsupported chainables on
     // unsuitable kinds (e.g. calling `.email()` on a number) throw at runtime
     // just like zod would.
@@ -104,6 +108,14 @@ function wrap(zs) {
     s.__zod = zs;
     return s;
 }
+// An unconstrained input stage preserves omission for unknown/any/custom fields.
+// The actual validator stays outside optional(), so required refinements still
+// run. A validation pipeline also keeps opaque promises synchronous.
+function withMissingInputValidation(schema) {
+    const input = z.unknown().optional().pipe(schema);
+    recordTransparentSchemaInput(input, schema);
+    return input;
+}
 function toZodShape(shape) {
     const out = {};
     for (const [key, value] of Object.entries(shape)) {
@@ -678,10 +690,10 @@ export function createZodAdapter() {
         boolean: () => wrap(z.boolean()),
         date: () => wrap(z.date()),
         null: () => wrap(z.null()),
-        unknown: () => wrap(z.unknown()),
+        unknown: () => wrap(withMissingInputValidation(z.unknown())),
         bigint: () => wrap(z.bigint()),
         // deno-lint-ignore no-explicit-any -- contract mirrors zod's `any` constructor
-        any: () => wrap(z.any()),
+        any: () => wrap(withMissingInputValidation(z.any())),
         function: () => 
         // zod 4's z.function() is callable without args/returns and produces a
         // schema accepting any function. We wrap it as Schema<AnyFunction>.
@@ -709,7 +721,7 @@ export function createZodAdapter() {
         // contract uses a slimmer `new`-able shape; bridge with a single cast
         // through unknown.
         wrap(z.instanceof(ctor)),
-        custom: (check, message) => wrap(z.custom(check, message)),
+        custom: (check, message) => wrap(withMissingInputValidation(z.custom(check, message))),
         coerce,
         validate: (schema, data) => schema.safeParse(data),
         compileJsonSchema,

package/esm/index.d.ts

@@ -12,6 +12,7 @@
  *
  * @module extensions/ext-schema-zod
  */
+import "./_dnt.polyfills.js";
 import type { ExtensionFactory } from "veryfront/extensions";
 declare const extZod: ExtensionFactory;
 export default extZod;

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,QAAA,MAAM,MAAM,EAAE,gBAiBb,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,QAAA,MAAM,MAAM,EAAE,gBAiBb,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/esm/index.js

@@ -12,6 +12,7 @@
  *
  * @module extensions/ext-schema-zod
  */
+import "./_dnt.polyfills.js";
 import { createZodAdapter } from "./adapter.js";
 const extZod = () => {
     const impl = createZodAdapter();

package/esm/json-schema.d.ts

@@ -10,6 +10,8 @@
  */
 import type { z } from "zod";
 import type { JsonSchema } from "veryfront/extensions/schema";
+/** Identity input stages do not change the public schema's metadata. */
+export declare function recordTransparentSchemaInput(schema: z.ZodTypeAny, represented: z.ZodTypeAny): void;
 /** Record a literal default without evaluating Zod's possibly dynamic getter. */
 export declare function recordStaticJsonSchemaDefault(schema: z.ZodTypeAny, value: unknown): void;
 export declare function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema;

package/esm/json-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAqO9D,iFAAiF;AACjF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOxF;AAmLD,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,CAMhE;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAE9D"}
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAwO9D,wEAAwE;AACxE,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,WAAW,EAAE,CAAC,CAAC,UAAU,GACxB,IAAI,CAON;AAMD,iFAAiF;AACjF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOxF;AAmLD,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,CAMhE;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAE9D"}

package/esm/json-schema.js

@@ -16,6 +16,7 @@ function assertConversionDepth(depth) {
     }
 }
 const STATIC_DEFAULT_VALUE = Symbol("veryfront.staticJsonSchemaDefault");
+const TRANSPARENT_INPUT_SCHEMA = Symbol("veryfront.transparentInputSchema");
 const LITERAL_TYPE_MAP = {
     string: "string",
     number: "number",
@@ -138,7 +139,7 @@ function originatesFromCustomSchema(schema) {
         if (tag !== "pipe" && tag !== "ZodEffects")
             return false;
         const def = getDef(current);
-        const input = def.schema ?? def.in;
+        const input = getTransparentInputSchema(def) ?? def.schema ?? def.in;
         if (!input || input === current)
             return false;
         current = input;
@@ -147,9 +148,24 @@ function originatesFromCustomSchema(schema) {
     return false;
 }
 function representedPipeSchema(def) {
+    const transparent = getTransparentInputSchema(def);
+    if (transparent)
+        return transparent;
     const input = def.schema ?? def.in;
     return input && originatesFromCustomSchema(input) && def.out ? def.out : input;
 }
+/** Identity input stages do not change the public schema's metadata. */
+export function recordTransparentSchemaInput(schema, represented) {
+    Object.defineProperty(getDef(schema), TRANSPARENT_INPUT_SCHEMA, {
+        configurable: true,
+        enumerable: true,
+        value: represented,
+        writable: false,
+    });
+}
+function getTransparentInputSchema(def) {
+    return Object.getOwnPropertyDescriptor(def, TRANSPARENT_INPUT_SCHEMA)?.value;
+}
 /** Record a literal default without evaluating Zod's possibly dynamic getter. */
 export function recordStaticJsonSchemaDefault(schema, value) {
     Object.defineProperty(getDef(schema), STATIC_DEFAULT_VALUE, {
@@ -604,7 +620,7 @@ function hasDefaultSchema(schema) {
             case "optional":
             case "ZodEffects":
             case "pipe": {
-                const inner = def.innerType ?? def.schema ?? def.in;
+                const inner = getTransparentInputSchema(def) ?? def.innerType ?? def.schema ?? def.in;
                 if (!inner || inner === current)
                     return false;
                 current = inner;

package/esm/object-data-properties.d.ts

@@ -0,0 +1,4 @@
+import type { z } from "zod";
+/** Preserve declared data without restoring unsafe unknown-key assignment. */
+export declare function preserveDeclaredObjectDataProperty(schema: z.ZodType): void;
+//# sourceMappingURL=object-data-properties.d.ts.map

package/esm/object-data-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-data-properties.d.ts","sourceRoot":"","sources":["../src/object-data-properties.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+E7B,8EAA8E;AAC9E,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAsC1E"}

package/esm/object-data-properties.js

@@ -0,0 +1,98 @@
+const DATA_KEY = "__proto__";
+const patched = new WeakSet();
+const HasOwn = Object.hasOwn;
+const DefineProperty = Object.defineProperty;
+const Get = Reflect.get;
+const Apply = Reflect.apply;
+const IsArray = Array.isArray;
+const NativePromise = Promise;
+const PromiseThen = Promise.prototype.then;
+function isSchemaObjectData(value) {
+    return value !== null && typeof value === "object" && !IsArray(value);
+}
+function continueParse(result, next) {
+    return result instanceof NativePromise
+        ? Apply(PromiseThen, result, [next])
+        : next(result);
+}
+function mergeDeclaredData(parent, child, field, present, output) {
+    for (let index = 0; index < child.issues.length; index++) {
+        const issue = child.issues[index];
+        parent.issues[parent.issues.length] = {
+            ...issue,
+            path: [DATA_KEY, ...(issue.path ?? [])],
+        };
+    }
+    // Ordinary fields retain values for non-aborting refinements; their issues
+    // still make validation fail. Defining data never calls the prototype setter.
+    if (present || child.value !== undefined ||
+        field._zod.optin === "defaulted" && field._zod.optout !== "optional") {
+        const descriptor = {
+            __proto__: null,
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: child.value,
+        };
+        DefineProperty(output, DATA_KEY, descriptor);
+    }
+    return parent;
+}
+function parseDeclaredData(parent, input, field, context) {
+    const output = parent.value;
+    if (!isSchemaObjectData(output)) {
+        throw new TypeError("Object schema parser returned an invalid output");
+    }
+    const present = HasOwn(input, DATA_KEY);
+    const parsed = field._zod.run({
+        value: present ? Get(input, DATA_KEY, input) : undefined,
+        issues: [],
+    }, context);
+    return continueParse(parsed, (child) => mergeDeclaredData(parent, child, field, present, output));
+}
+/** Preserve declared data without restoring unsafe unknown-key assignment. */
+export function preserveDeclaredObjectDataProperty(schema) {
+    if (schema._zod.def.type !== "object" || patched.has(schema))
+        return;
+    const object = schema;
+    const shape = object._zod.def.shape;
+    if (!HasOwn(shape, DATA_KEY))
+        return;
+    const field = shape[DATA_KEY];
+    let delegate = object._zod.parse;
+    const directRun = object._zod.run === delegate;
+    // Zod4.6 skips this name even in a declared shape. Validate it through its
+    // actual field parser, then define an own data property before object checks.
+    // No shared prototype or global parser changes; wrap() patches each clone.
+    const parse = (payload, context) => {
+        const input = payload.value;
+        const issueCount = payload.issues.length;
+        const result = delegate(payload, context);
+        if (!isSchemaObjectData(input))
+            return result;
+        return continueParse(result, (parent) => {
+            if (parent.memo || context.abortEarly && parent.issues.length > issueCount)
+                return parent;
+            return parseDeclaredData(parent, input, field, context);
+        });
+    };
+    // The memoizer replaces its parser from inside the first call. Keep this
+    // instance's augmentation installed even during reentrant validation, while
+    // allowing that replacement to become the delegate for subsequent calls.
+    const descriptor = {
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        get: () => parse,
+        set(next) {
+            if (typeof next !== "function")
+                throw new TypeError("Object schema parser is unavailable");
+            if (next !== parse)
+                delegate = next;
+        },
+    };
+    DefineProperty(object._zod, "parse", descriptor);
+    if (directRun)
+        object._zod.run = parse;
+    patched.add(schema);
+}

package/esm/union-diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+/** Adapt upstream #6662 for eager collection bounds without changing custom type errors. */
+export declare function preserveUnionCheckDiagnostics(schema: z.ZodType): void;
+//# sourceMappingURL=union-diagnostics.d.ts.map

package/esm/union-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-diagnostics.d.ts","sourceRoot":"","sources":["../src/union-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmDxB,4FAA4F;AAC5F,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CA4BrE"}

package/esm/union-diagnostics.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const patched = new WeakSet();
+function isCollectionSizeRefusal(issue) {
+    return issue.code === "too_big" &&
+        (issue.origin === "array" || issue.origin === "set" || issue.origin === "map");
+}
+function selectUnionResult(results, final, union, context) {
+    for (const result of results) {
+        if (result.issues.length === 0) {
+            final.value = result.value;
+            return final;
+        }
+    }
+    let matched = results.filter((result) => !z.core.util.aborted(result));
+    if (matched.length === 0) {
+        // Only eager collection caps need the fallback. A failed custom type
+        // predicate must retain its enclosing union's original error boundary.
+        matched = results.filter((result) => !result.aborted &&
+            result.issues.every((issue) => issue.continue === true || issue.continue === false && isCollectionSizeRefusal(issue)) && result.issues.some(isCollectionSizeRefusal));
+    }
+    if (matched.length === 1) {
+        final.value = matched[0].value;
+        return matched[0];
+    }
+    final.issues.push({
+        code: "invalid_union",
+        input: final.value,
+        inst: union,
+        errors: results.map((result) => result.issues.map((issue) => z.core.util.finalizeIssue(issue, context, z.core.config()))),
+    });
+    return final;
+}
+/** Adapt upstream #6662 for eager collection bounds without changing custom type errors. */
+export function preserveUnionCheckDiagnostics(schema) {
+    const def = schema._zod.def;
+    if (def.type !== "union" || "discriminator" in def || "exclusive" in def || patched.has(schema))
+        return;
+    const union = schema;
+    const options = union._zod.def.options;
+    const previous = union._zod.parse;
+    const directRun = union._zod.run === previous;
+    const parse = (payload, context) => {
+        if (options.length === 1)
+            return options[0]._zod.run(payload, context);
+        const results = [];
+        let asynchronous = false;
+        for (const option of options) {
+            const result = option._zod.run({ value: payload.value, issues: [] }, context);
+            if (result instanceof Promise)
+                asynchronous = true;
+            else if (result.issues.length === 0)
+                return result;
+            results.push(result);
+        }
+        return asynchronous
+            ? Promise.all(results).then((resolved) => selectUnionResult(resolved, payload, union, context))
+            : selectUnionResult(results, payload, union, context);
+    };
+    union._zod.parse = parse;
+    if (directRun)
+        union._zod.run = parse;
+    patched.add(schema);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-schema-zod",
-  "version": "0.1.1284",
+  "version": "0.1.1285",
   "description": "Veryfront first-party extension package for ext-schema-zod",
   "keywords": [
     "veryfront",
@@ -44,10 +44,10 @@
   "dependencies": {
     "ajv": "8.18.0",
     "ajv-formats": "3.0.1",
-    "zod": "4.3.6"
+    "zod": "4.6.7"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1284"
+    "veryfront": "^0.1.1285"
   },
   "type": "module",
   "types": "./esm/index.d.ts",
@@ -57,5 +57,5 @@
     "NOTICE",
     "README.md"
   ],
-  "gitHead": "ee34c936d96f979a54dc2f32def75772677f4cfd"
+  "gitHead": "2bac963100515224f14213021beb42e128b201ea"
 }