@frontmcp/lazy-zod 1.7.0 → 1.7.1

package/esm/index.mjs

@@ -227,16 +227,28 @@ function deepMaterialize(value, seen) {
 
 // libs/lazy-zod/src/lazy-z.ts
 import { z as realZ } from "zod";
-var lazyProxy = new Proxy(realZ, {
-  get(target, key, receiver) {
-    if (typeof key === "string" && HEAVY_FACTORIES.has(key)) {
-      const realFactory = target[key];
-      return (...args) => wrapLazy(new LazyZodSchema(() => realFactory.call(target, ...args)));
-    }
-    return Reflect.get(target, key, receiver);
-  }
-});
-var z = lazyProxy;
+function createLazyZ(namespace) {
+  return new Proxy({}, {
+    get(_target, key, receiver) {
+      if (typeof key === "string" && HEAVY_FACTORIES.has(key)) {
+        const realFactory = namespace[key];
+        return (...args) => wrapLazy(
+          new LazyZodSchema(() => realFactory.call(namespace, ...args))
+        );
+      }
+      return Reflect.get(namespace, key, receiver);
+    },
+    set: (_target, key, value) => Reflect.set(namespace, key, value),
+    has: (_target, key) => Reflect.has(namespace, key),
+    ownKeys: () => Reflect.ownKeys(namespace),
+    getOwnPropertyDescriptor(_target, key) {
+      const desc = Reflect.getOwnPropertyDescriptor(namespace, key);
+      return desc ? { ...desc, configurable: true } : void 0;
+    },
+    getPrototypeOf: () => Reflect.getPrototypeOf(namespace)
+  });
+}
+var z = createLazyZ(realZ);
 
 // libs/lazy-zod/src/eager-z.ts
 import { z as z2 } from "zod";

package/esm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/lazy-zod",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Drop-in zod replacement that lazily constructs compound schemas for dramatic cold-start speedups. Exports `z` (lazy, drop-in), `eagerZ` (real zod, zero overhead), and `lazyZ` (explicit factory wrapper).",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",

package/index.js

@@ -287,16 +287,28 @@ function deepMaterialize(value, seen) {
 
 // libs/lazy-zod/src/lazy-z.ts
 var import_zod = require("zod");
-var lazyProxy = new Proxy(import_zod.z, {
-  get(target, key, receiver) {
-    if (typeof key === "string" && HEAVY_FACTORIES.has(key)) {
-      const realFactory = target[key];
-      return (...args) => wrapLazy(new LazyZodSchema(() => realFactory.call(target, ...args)));
-    }
-    return Reflect.get(target, key, receiver);
-  }
-});
-var z = lazyProxy;
+function createLazyZ(namespace) {
+  return new Proxy({}, {
+    get(_target, key, receiver) {
+      if (typeof key === "string" && HEAVY_FACTORIES.has(key)) {
+        const realFactory = namespace[key];
+        return (...args) => wrapLazy(
+          new LazyZodSchema(() => realFactory.call(namespace, ...args))
+        );
+      }
+      return Reflect.get(namespace, key, receiver);
+    },
+    set: (_target, key, value) => Reflect.set(namespace, key, value),
+    has: (_target, key) => Reflect.has(namespace, key),
+    ownKeys: () => Reflect.ownKeys(namespace),
+    getOwnPropertyDescriptor(_target, key) {
+      const desc = Reflect.getOwnPropertyDescriptor(namespace, key);
+      return desc ? { ...desc, configurable: true } : void 0;
+    },
+    getPrototypeOf: () => Reflect.getPrototypeOf(namespace)
+  });
+}
+var z = createLazyZ(import_zod.z);
 
 // libs/lazy-zod/src/eager-z.ts
 var import_zod2 = require("zod");

package/lazy-z.d.ts

@@ -1,4 +1,35 @@
 import { z as realZ } from 'zod';
+/**
+ * Build the lazy `z` Proxy over a zod namespace object.
+ *
+ * The Proxy target is a fresh empty object, NOT the namespace itself. zod >= 4.6
+ * `Object.freeze`s its namespace, so every export became a non-configurable,
+ * non-writable DATA property — and a `get` trap that returns anything other than
+ * the value the target holds violates a Proxy invariant:
+ *
+ *   TypeError: 'get' on proxy: property 'object' is a read-only and
+ *   non-configurable data property on the proxy target but the proxy did not
+ *   return its actual value
+ *
+ * which is exactly what swapping in a lazy factory does. An empty, extensible
+ * target owns nothing, so no invariant applies; every trap forwards to
+ * `namespace` instead. Exported for tests — the public entry point is `z`.
+ */
+export declare function createLazyZ(namespace: typeof realZ): typeof realZ;
+/**
+ * Lazy-by-default `z`. Proxy over real zod's `z`:
+ *  - Heavy compound factories (`object`, `union`, `discriminatedUnion`,
+ *    `intersection`, `record`, `tuple`) return a `LazyZodSchema` Proxy —
+ *    construction deferred until first `.parse()`.
+ *  - Everything else (`string`, `number`, `boolean`, `enum`, `literal`,
+ *    `lazy`, `custom`, etc.) passes through unchanged. Primitives are
+ *    already cheap; the type constructors are phantom at runtime.
+ *
+ * Typed as `typeof realZ` so every zod value helper works identically,
+ * and a declaration-merged `namespace z` below re-exports zod's type
+ * namespace so `z.infer<T>`, `z.ZodObject<Shape>`, `z.ZodRawShape`, etc.
+ * resolve at the TYPE level (a const alone doesn't expose the namespace).
+ */
 export declare const z: typeof realZ;
 export declare namespace z {
     type infer<T> = realZ.infer<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/lazy-zod",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Drop-in zod replacement that lazily constructs compound schemas for dramatic cold-start speedups. Exports `z` (lazy, drop-in), `eagerZ` (real zod, zero overhead), and `lazyZ` (explicit factory wrapper).",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",