@wildo-ai/zod-decorators 1.0.0

package/dist/esm/zod.module-override.js

@@ -0,0 +1,1093 @@
+import { z } from 'zod';
+import { SCHEMA_METADATA, ZodDecorator } from './zod-decorators.types.js';
+const ApplyableTypeAllTypes = ["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodDate", "ZodEnum", "ZodOptional", "ZodArray", "ZodObject"];
+const ApplyableTypeAllPrimitiveTypes = ["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodDate", "ZodEnum", "ZodOptional"];
+const ApplyableTypeAllArrayTypes = ["ZodArray"];
+const ApplyableTypeAllObjectTypes = ["ZodObject", "ZodRecord", "ZodMap"];
+/**
+ * List of Zod methods that return new instances and need wrapping
+ */
+const ZOD_INSTANCE_METHODS_TO_WRAP = [
+    'min', 'max', 'length', 'email', 'url', 'uuid', 'nanoid', 'cuid', 'cuid2', 'ulid',
+    'regex', 'includes', 'startsWith', 'endsWith', 'datetime', 'date', 'time', 'duration',
+    'ip', 'base64', 'trim', 'toLowerCase', 'toUpperCase', 'jwt', 'emoji',
+    'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+    'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine',
+    'int', 'positive', 'negative', 'nonnegative', 'nonpositive', 'multipleOf', 'finite', 'safe', 'step',
+    'nonempty',
+    // Object/record methods that return new schema instances (Zod v4)
+    'extend', 'merge', 'pick', 'omit', 'partial', 'deepPartial', 'required',
+    'strict', 'passthrough', 'strip', 'catchall',
+    // Misc helpers that return new schema instances
+    'meta', 'prefault'
+];
+// Types that support field-level decorators (hidden, notEditable, sortable, showWhen, draft, etc.): primitives + object roots + arrays
+const ApplyableTypeFormField = [...ApplyableTypeAllPrimitiveTypes, "ZodObject", "ZodArray"];
+export const ZodDecorator_ApplyableType = {
+    [ZodDecorator.IS_DB_INDEXED]: [...ApplyableTypeAllPrimitiveTypes, "ZodObject"],
+    [ZodDecorator.IS_FOREIGN_KEY]: ["ZodString"],
+    [ZodDecorator.IS_HIDDEN]: ApplyableTypeFormField,
+    [ZodDecorator.IS_NOT_EDITABLE]: ApplyableTypeFormField,
+    // New decorators - apply to all types since they are schema-level metadata
+    [ZodDecorator.IS_SUMMARY_FIELD]: ApplyableTypeAllTypes,
+    [ZodDecorator.IS_BACKEND_ONLY]: ApplyableTypeAllTypes,
+    [ZodDecorator.IS_VIRTUAL]: ApplyableTypeAllTypes,
+    [ZodDecorator.IS_DISCRIMINATOR]: ApplyableTypeAllPrimitiveTypes, // Only primitives can be discriminators
+    [ZodDecorator.EXCLUDE_FROM_CREATE]: ApplyableTypeAllTypes,
+    [ZodDecorator.EXCLUDE_FROM_UPDATE]: ApplyableTypeAllTypes,
+    // Database constraint decorators - only strings and numbers can be unique (identifiers, codes, etc.)
+    // ZodOptional is included to support chaining like z.string().isUnique().optional()
+    [ZodDecorator.IS_UNIQUE]: ['ZodString', 'ZodNumber', 'ZodOptional'],
+    // Primary key is only for strings (MongoDB _id is always a string or ObjectId)
+    [ZodDecorator.IS_PRIMARY_KEY]: ['ZodString'],
+    // TTL (Time To Live) - only for Date fields (MongoDB TTL indexes work on Date fields)
+    [ZodDecorator.TTL]: ['ZodDate', 'ZodOptional'],
+    // String edit mode convenience decorators - only for strings
+    [ZodDecorator.IS_PASSWORD]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.IS_OTP]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.IS_COLOR]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.IS_DRAFT_RELAXED]: ApplyableTypeFormField,
+    // FIX-P5-H1: Conditional visibility decorator - apply to all form field types
+    [ZodDecorator.SHOW_WHEN]: ApplyableTypeFormField,
+    // System enum decorator - marks enum fields as using a system-level enum for labelling
+    [ZodDecorator.SYSTEM_ENUM]: ['ZodEnum', 'ZodOptional'],
+    // Ephemeral field decorator - only for strings (API keys, tokens, etc.)
+    [ZodDecorator.IS_EPHEMERAL]: ['ZodString', 'ZodOptional'],
+    // CRDT field decorator — all field types can be CRDT-enabled
+    [ZodDecorator.IS_CRDT]: ApplyableTypeAllTypes,
+    // Unified {primitive}UI decorators — each constrained to its applicable schema types
+    [ZodDecorator.BOOLEAN_UI]: ['ZodBoolean', 'ZodOptional'],
+    [ZodDecorator.STRING_UI]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.NUMBER_UI]: ['ZodNumber', 'ZodOptional'],
+    [ZodDecorator.ENUM_UI]: ['ZodEnum', 'ZodOptional'],
+    [ZodDecorator.DATE_UI]: ['ZodDate', 'ZodOptional'],
+    [ZodDecorator.DATETIME_UI]: ['ZodDate', 'ZodOptional'],
+    [ZodDecorator.TIME_UI]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.MONEY_UI]: ['ZodObject', 'ZodOptional'],
+    [ZodDecorator.CODE_UI]: ['ZodObject', 'ZodOptional'],
+    [ZodDecorator.FILE_UI]: ['ZodObject', 'ZodOptional'],
+    [ZodDecorator.DURATION_UI]: ['ZodObject', 'ZodOptional'],
+    [ZodDecorator.PHONE_UI]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.BIGDECIMAL_UI]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.FOREIGN_KEY_UI]: ['ZodString', 'ZodOptional'],
+    [ZodDecorator.ARRAY_UI]: ['ZodArray', 'ZodOptional'],
+    [ZodDecorator.OBJECT_UI]: [...ApplyableTypeAllObjectTypes, 'ZodOptional'],
+};
+export const ZodDecorator_FunctionType = {
+    isDBIndexed: function () { return addDecorators(this, [ZodDecorator.IS_DB_INDEXED]); },
+    isForeignKey: function (params) { return params ? addDecorators(this, [{ ref: ZodDecorator.IS_FOREIGN_KEY, params }]) : addDecorators(this, [ZodDecorator.IS_FOREIGN_KEY]); },
+    isHidden: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_HIDDEN, params }]); },
+    isNotEditable: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_NOT_EDITABLE, params }]); },
+    isSortable: function (params) { return addDecorators(this, [{ ref: ZodDecorator.ARRAY_UI, params: { edit: { isSortable: true, ...params } } }]); },
+    // String edit mode convenience composites — structural marker + STRING_UI side effect
+    [ZodDecorator.IS_PASSWORD]: function () { return addDecorators(this, [{ ref: ZodDecorator.IS_PASSWORD, params: undefined }, { ref: ZodDecorator.STRING_UI, params: { edit: { editMode: 'password' } } }]); },
+    [ZodDecorator.IS_OTP]: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_OTP, params }, { ref: ZodDecorator.STRING_UI, params: { edit: { editMode: 'otp' } } }]); },
+    [ZodDecorator.IS_COLOR]: function () { return addDecorators(this, [{ ref: ZodDecorator.IS_COLOR, params: undefined }, { ref: ZodDecorator.STRING_UI, params: { edit: { editMode: 'color' } } }]); },
+    // New decorators for resource derived objects rationalization
+    isSummaryField: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_SUMMARY_FIELD, params }]); },
+    isBackendOnly: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_BACKEND_ONLY, params }]); },
+    isVirtual: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_VIRTUAL, params }]); },
+    isDiscriminator: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_DISCRIMINATOR, params }]); },
+    excludeFromCreate: function () { return addDecorators(this, [ZodDecorator.EXCLUDE_FROM_CREATE]); },
+    excludeFromUpdate: function () { return addDecorators(this, [ZodDecorator.EXCLUDE_FROM_UPDATE]); },
+    // Database constraint decorators
+    isUnique: function (params) { return addDecorators(this, [{ ref: ZodDecorator.IS_UNIQUE, params }]); },
+    // isPrimaryKey is a composite decorator: implies excludeFromCreate + isHidden + isUnique(sparse:false) + isDBIndexed
+    isPrimaryKey: function () {
+        return addDecorators(this, [
+            ZodDecorator.IS_PRIMARY_KEY,
+            ZodDecorator.EXCLUDE_FROM_CREATE,
+            ZodDecorator.IS_HIDDEN,
+            ZodDecorator.IS_DB_INDEXED,
+            { ref: ZodDecorator.IS_UNIQUE, params: { scope: 'global', sparse: false } },
+        ]);
+    },
+    // TTL (Time To Live) - for automatic document expiration in MongoDB
+    ttl: function (params) { return addDecorators(this, [{ ref: ZodDecorator.TTL, params }]); },
+    isDraftRelaxed: function () { return addDecorators(this, [ZodDecorator.IS_DRAFT_RELAXED]); },
+    // FIX-P5-H1: Conditional visibility decorator
+    showWhen: function (params) { return addDecorators(this, [{ ref: ZodDecorator.SHOW_WHEN, params }]); },
+    // System enum decorator - marks an enum field as using a system-level enum for i18n labelling
+    systemEnum: function (name) { return addDecorators(this, [{ ref: ZodDecorator.SYSTEM_ENUM, params: name }]); },
+    // Ephemeral field decorator — composite: marks response-only transient data + sets secret display mode + prevents editing
+    isEphemeral: function () { return addDecorators(this, [{ ref: ZodDecorator.IS_EPHEMERAL, params: undefined }, { ref: ZodDecorator.STRING_UI, params: { display: { displayMode: 'secret' } } }, { ref: ZodDecorator.IS_NOT_EDITABLE, params: undefined }]); },
+    // CRDT field decorator — boolean marker for future field-level LWW merge
+    isCRDT: function () { return addDecorators(this, [ZodDecorator.IS_CRDT]); },
+    // Unified {primitive}UI decorators — new API
+    booleanUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.BOOLEAN_UI, params }]); },
+    stringUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.STRING_UI, params }]); },
+    numberUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.NUMBER_UI, params }]); },
+    enumUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.ENUM_UI, params }]); },
+    dateUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.DATE_UI, params }]); },
+    dateTimeUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.DATETIME_UI, params }]); },
+    timeUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.TIME_UI, params }]); },
+    moneyUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.MONEY_UI, params }]); },
+    codeUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.CODE_UI, params }]); },
+    fileUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.FILE_UI, params }]); },
+    durationUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.DURATION_UI, params }]); },
+    phoneUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.PHONE_UI, params }]); },
+    bigDecimalUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.BIGDECIMAL_UI, params }]); },
+    foreignKeyUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.FOREIGN_KEY_UI, params }]); },
+    arrayUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.ARRAY_UI, params }]); },
+    objectUI: function (params) { return addDecorators(this, [{ ref: ZodDecorator.OBJECT_UI, params }]); },
+};
+// =============================================================================
+// MAIN ADD UTILITIES
+// =============================================================================
+export function ZodDecorator_FunctionAddDecorators(decorators) {
+    return addDecorators(this, decorators);
+}
+export const defaultZodDecoSchemaProperties = {
+    enumerable: false,
+    writable: false,
+};
+export function addDecorators(schema, decoratorInputs) {
+    // Lazy initialization: ensure decorators are loaded when first used
+    ensureZodDecoratorsLoaded(z);
+    let resultSchema = schema;
+    // Apply each decorator in sequence
+    for (const decoratorInput of decoratorInputs) {
+        resultSchema = (typeof decoratorInput === 'string')
+            ? applySingleDecorator(resultSchema, decoratorInput)
+            : applySingleDecorator(resultSchema, decoratorInput.ref, decoratorInput.params);
+    }
+    // Add all chainable methods to the final schema
+    return addChainableMethods(resultSchema);
+}
+/**
+ * Deep-clone a value, preserving function references (React components in `IconLike`).
+ * - Primitives & functions: returned by reference
+ * - Arrays: cloned recursively
+ * - Date, RegExp: cloned via constructors
+ * - Plain objects: cloned recursively with independent property copies
+ * - Shared sub-objects: cloned once and reused (WeakMap tracks original→clone)
+ * - Circular references: safely resolved via the shared-reference map
+ */
+function deepCloneValue(value, seen) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return value;
+    }
+    if (!seen)
+        seen = new WeakMap();
+    const cached = seen.get(value);
+    if (cached !== undefined)
+        return cached;
+    if (value instanceof Date) {
+        const cloned = new Date(value.getTime());
+        seen.set(value, cloned);
+        return cloned;
+    }
+    if (value instanceof RegExp) {
+        const cloned = new RegExp(value.source, value.flags);
+        seen.set(value, cloned);
+        return cloned;
+    }
+    if (Array.isArray(value)) {
+        const cloned = [];
+        seen.set(value, cloned);
+        for (const v of value)
+            cloned.push(deepCloneValue(v, seen));
+        return cloned;
+    }
+    const result = {};
+    seen.set(value, result);
+    for (const [k, v] of Object.entries(value)) {
+        result[k] = deepCloneValue(v, seen);
+    }
+    return result;
+}
+/**
+ * Clone a Zod schema with an independent deep-copy of its decorator metadata.
+ *
+ * Creates a new schema instance that shares the same Zod validation behavior
+ * but has independent decorator metadata. Mutations (`.enumUI()`,
+ * `.isDBIndexed()`, etc.) on the clone do not affect the original, and vice versa.
+ *
+ * Function references (React components in `IconLike`) are preserved by reference;
+ * all other metadata values (objects, arrays, primitives) are deep-cloned.
+ *
+ * **Use case:** reusable leaf schemas (enums, strings, numbers) with shared visual
+ * config but independent field-level decorators per resource.
+ *
+ * **Scope limitations:** designed for leaf schemas, NOT for compound types:
+ * - **`z.object()`:** field schemas inside the shape remain shared references —
+ *   mutating a field's decorators on the clone affects the original.
+ * - **Wrapper types** (`.optional()`, `.nullable()`, `.array()`, `.pipe()`):
+ *   the inner schema remains shared. Clone the unwrapped schema first, then wrap.
+ *
+ * @example
+ * ```ts
+ * // Master enum with common visual config
+ * const PriorityEnum = z.enum(Priority)
+ *   .systemEnum('Priority')
+ *   .enumUI({ values: { low: { color: 'secondary' }, high: { color: 'destructive' } } });
+ *
+ * // Each resource gets an independent clone
+ * const TodosSchema = z.object({
+ *   priority: z_clone(PriorityEnum).isDBIndexed().isSummaryField(),
+ * });
+ * const TasksSchema = z.object({
+ *   priority: z_clone(PriorityEnum).isNotEditable(),
+ * });
+ * // TodosSchema.priority has isDBIndexed + isSummaryField — TasksSchema.priority does not
+ * ```
+ */
+export function z_clone(schema) {
+    const clone = Object.assign(Object.create(Object.getPrototypeOf(schema)), schema);
+    const metadata = schema[SCHEMA_METADATA];
+    if (metadata) {
+        clone[SCHEMA_METADATA] = deepCloneValue(metadata);
+    }
+    return addChainableMethods(clone);
+}
+/**
+ * Deep-merge ENUM_UI decorator params with special handling for the `values` key.
+ *
+ * - `values` is deep-merged: per-enum-value configs merge individually
+ *   (e.g., adding an icon to a value that already has a color preserves both).
+ * - All other top-level keys are shallow-replaced (e.g., `displayMode` is atomic).
+ * - Additive only — you cannot remove a value entry set by a prior call.
+ *   To visually "clear" a property, set it to `undefined` explicitly.
+ */
+function deepMergeDisplayParams(existing, incoming) {
+    const result = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+        if (key === 'values' &&
+            value && typeof value === 'object' &&
+            result[key] && typeof result[key] === 'object') {
+            const existingValues = result[key];
+            const incomingValues = value;
+            result[key] = { ...existingValues };
+            for (const [enumValue, enumConfig] of Object.entries(incomingValues)) {
+                result[key][enumValue] = existingValues[enumValue]
+                    ? { ...existingValues[enumValue], ...enumConfig }
+                    : enumConfig;
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function applySingleDecorator(schema, decorator, params) {
+    // Ensure schema exists before accessing Symbol property
+    if (!schema) {
+        throw new Error('Invalid schema provided to applySingleDecorator');
+    }
+    // Get existing metadata from Symbol property with proper type casting
+    const currentMetadata = schema[SCHEMA_METADATA] || {};
+    // Generic updater function resolution: if params is a function, call it with
+    // the current metadata value and use the result. Works for any decorator.
+    let resolvedFromUpdater = false;
+    if (typeof params === 'function') {
+        const existing = currentMetadata[decorator];
+        const currentValue = (existing && typeof existing === 'object') ? existing : undefined;
+        params = params(currentValue);
+        resolvedFromUpdater = true;
+    }
+    // After function resolution, params is a concrete value (never a function).
+    // TypeScript can't narrow this from control flow. Use `rp<D>()` for typed
+    // access in cases that read properties; use `p` for simple assignments.
+    const p = params;
+    function rp() {
+        return params;
+    }
+    // Handle each decorator explicitly.
+    // `p` is used instead of `params` for assignments — it's the same value
+    // but typed as `any` since TypeScript can't narrow the function union away
+    // after the generic resolution above.
+    switch (decorator) {
+        case ZodDecorator.IS_DB_INDEXED:
+            currentMetadata[ZodDecorator.IS_DB_INDEXED] = true;
+            break;
+        case ZodDecorator.IS_FOREIGN_KEY:
+            currentMetadata[ZodDecorator.IS_FOREIGN_KEY] = p ?? true;
+            break;
+        case ZodDecorator.IS_HIDDEN:
+            currentMetadata[ZodDecorator.IS_HIDDEN] = p ?? true;
+            break;
+        case ZodDecorator.IS_NOT_EDITABLE:
+            currentMetadata[ZodDecorator.IS_NOT_EDITABLE] = p ?? true;
+            break;
+        case ZodDecorator.IS_SUMMARY_FIELD:
+            currentMetadata[ZodDecorator.IS_SUMMARY_FIELD] = p ?? true;
+            break;
+        case ZodDecorator.IS_BACKEND_ONLY:
+            currentMetadata[ZodDecorator.IS_BACKEND_ONLY] = p ?? true;
+            break;
+        case ZodDecorator.IS_VIRTUAL: {
+            const vp = rp();
+            if (!vp?.calculate) {
+                throw new Error('isVirtual decorator requires a calculate function');
+            }
+            currentMetadata[ZodDecorator.IS_VIRTUAL] = vp;
+            break;
+        }
+        case ZodDecorator.IS_DISCRIMINATOR:
+            currentMetadata[ZodDecorator.IS_DISCRIMINATOR] = p ?? true;
+            break;
+        case ZodDecorator.EXCLUDE_FROM_CREATE:
+            currentMetadata[ZodDecorator.EXCLUDE_FROM_CREATE] = true;
+            break;
+        case ZodDecorator.EXCLUDE_FROM_UPDATE:
+            currentMetadata[ZodDecorator.EXCLUDE_FROM_UPDATE] = true;
+            break;
+        case ZodDecorator.IS_UNIQUE:
+            currentMetadata[ZodDecorator.IS_UNIQUE] = p ?? true;
+            break;
+        case ZodDecorator.IS_PRIMARY_KEY:
+            currentMetadata[ZodDecorator.IS_PRIMARY_KEY] = true;
+            break;
+        case ZodDecorator.TTL:
+            currentMetadata[ZodDecorator.TTL] = p;
+            break;
+        case ZodDecorator.IS_PASSWORD:
+            currentMetadata[ZodDecorator.IS_PASSWORD] = true;
+            break;
+        case ZodDecorator.IS_OTP:
+            currentMetadata[ZodDecorator.IS_OTP] = p ?? true;
+            break;
+        case ZodDecorator.IS_COLOR:
+            currentMetadata[ZodDecorator.IS_COLOR] = true;
+            break;
+        case ZodDecorator.IS_DRAFT_RELAXED:
+            currentMetadata[ZodDecorator.IS_DRAFT_RELAXED] = true;
+            break;
+        case ZodDecorator.SHOW_WHEN:
+            currentMetadata[ZodDecorator.SHOW_WHEN] = p;
+            break;
+        case ZodDecorator.SYSTEM_ENUM:
+            currentMetadata[ZodDecorator.SYSTEM_ENUM] = p;
+            break;
+        case ZodDecorator.IS_EPHEMERAL:
+            currentMetadata[ZodDecorator.IS_EPHEMERAL] = true;
+            break;
+        case ZodDecorator.IS_CRDT:
+            currentMetadata[ZodDecorator.IS_CRDT] = true;
+            break;
+        // Unified {primitive}UI decorators — ENUM_UI uses deep merge for per-value configs, all others use shallow replace
+        case ZodDecorator.ENUM_UI: {
+            if (!p) {
+                currentMetadata[decorator] = true;
+            }
+            else if (resolvedFromUpdater) {
+                currentMetadata[decorator] = p;
+            }
+            else {
+                const existing = currentMetadata[decorator];
+                currentMetadata[decorator] =
+                    (existing && typeof existing === 'object')
+                        ? deepMergeDisplayParams(existing, p)
+                        : p;
+            }
+            break;
+        }
+        case ZodDecorator.BOOLEAN_UI:
+        case ZodDecorator.STRING_UI:
+        case ZodDecorator.NUMBER_UI:
+        case ZodDecorator.DATE_UI:
+        case ZodDecorator.DATETIME_UI:
+        case ZodDecorator.TIME_UI:
+        case ZodDecorator.MONEY_UI:
+        case ZodDecorator.CODE_UI:
+        case ZodDecorator.FILE_UI:
+        case ZodDecorator.DURATION_UI:
+        case ZodDecorator.PHONE_UI:
+        case ZodDecorator.BIGDECIMAL_UI:
+        case ZodDecorator.FOREIGN_KEY_UI:
+        case ZodDecorator.ARRAY_UI:
+        case ZodDecorator.OBJECT_UI: {
+            if (!p) {
+                currentMetadata[decorator] = true;
+            }
+            else if (resolvedFromUpdater) {
+                currentMetadata[decorator] = p;
+            }
+            else {
+                currentMetadata[decorator] = p;
+            }
+            break;
+        }
+    }
+    // Store updated metadata using Symbol
+    schema[SCHEMA_METADATA] = currentMetadata;
+    return addChainableMethods(schema);
+}
+/**
+ * Methods that transform object fields and need special handling for field-level metadata.
+ * These methods create new field wrappers and we need to copy field-level metadata.
+ */
+const OBJECT_FIELD_TRANSFORM_METHODS_SET = new Set(['partial', 'deepPartial', 'required']);
+/**
+ * Wraps an instance method to preserve SCHEMA_METADATA when it returns a new instance.
+ * In Zod v4, methods are on instances not prototypes, so we wrap them individually.
+ * Also wraps the result's methods to ensure metadata persists through the entire chain.
+ */
+function wrapInstanceMethod(instance, methodName) {
+    const originalMethod = instance[methodName];
+    if (typeof originalMethod !== 'function')
+        return;
+    // Skip if already wrapped
+    if (originalMethod.__metadataWrapped)
+        return;
+    // Use special wrapper for field-transform methods on ZodObject
+    const isObjectFieldTransform = OBJECT_FIELD_TRANSFORM_METHODS_SET.has(methodName) &&
+        instance.constructor?.name === 'ZodObject';
+    const wrappedMethod = function (...args) {
+        // Get original shape before transformation (for field-transform methods)
+        const originalShape = isObjectFieldTransform ? this.shape : null;
+        const originalSchemaMetadata = this[SCHEMA_METADATA];
+        const result = originalMethod.apply(this, args);
+        // Copy metadata from original to result if it exists and result is different
+        if (result && result !== this) {
+            // Preserve all decorator metadata (including rangeConfig and currencyConfig)
+            if (originalSchemaMetadata && Object.keys(originalSchemaMetadata).length > 0) {
+                result[SCHEMA_METADATA] = { ...originalSchemaMetadata };
+            }
+            // For field-transform methods, copy field-level metadata to new wrapped fields
+            if (isObjectFieldTransform && originalShape && result.shape) {
+                copyFieldMetadata(originalShape, result.shape);
+            }
+            // Also wrap the result's methods so metadata persists through subsequent chains
+            wrapInstanceMethodsForMetadata(result);
+        }
+        return result;
+    };
+    // Mark as wrapped to avoid double-wrapping
+    wrappedMethod.__metadataWrapped = true;
+    instance[methodName] = wrappedMethod;
+}
+/**
+ * Copy field-level metadata from original shape to new shape.
+ * Used for methods like .partial() that wrap fields in new types.
+ */
+function copyFieldMetadata(originalShape, newShape) {
+    for (const fieldName of Object.keys(originalShape)) {
+        const originalField = originalShape[fieldName];
+        const newField = newShape[fieldName];
+        if (originalField && newField && originalField !== newField) {
+            const fieldMetadata = originalField[SCHEMA_METADATA];
+            if (fieldMetadata && Object.keys(fieldMetadata).length > 0) {
+                newField[SCHEMA_METADATA] = deepCloneValue(fieldMetadata);
+                // Also wrap the new field's methods for future chaining
+                wrapInstanceMethodsForMetadata(newField);
+            }
+        }
+    }
+}
+/**
+ * Wrap only the instance methods (not decorator methods) for metadata preservation.
+ * Used when copying metadata to a new schema instance.
+ */
+function wrapInstanceMethodsForMetadata(schema) {
+    for (const methodName of ZOD_INSTANCE_METHODS_TO_WRAP) {
+        if (typeof schema[methodName] === 'function') {
+            wrapInstanceMethod(schema, methodName);
+        }
+    }
+}
+export function addChainableMethods(schema) {
+    const decoratedSchema = schema;
+    // CRITICAL: Wrap instance methods that return new instances to preserve metadata
+    // In Zod v4, methods are on instances not prototypes
+    for (const methodName of ZOD_INSTANCE_METHODS_TO_WRAP) {
+        if (typeof decoratedSchema[methodName] === 'function') {
+            wrapInstanceMethod(decoratedSchema, methodName);
+        }
+    }
+    const ctorName = decoratedSchema?.constructor?.name;
+    for (const decorator of Object.values(ZodDecorator)) {
+        const applyable = ZodDecorator_ApplyableType[decorator];
+        if (!applyable || !ctorName)
+            continue;
+        if (!applyable.includes(ctorName))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(decoratedSchema, decorator))
+            continue;
+        // Use the actual function from ZodDecorator_FunctionType to preserve composite
+        // decorator behavior (e.g., isPrimaryKey sets 5 decorators, isPassword sets 2).
+        // Falling back to a generic wrapper should never happen if the table is complete.
+        const registeredFn = ZodDecorator_FunctionType[decorator];
+        const value = registeredFn
+            ? (...args) => registeredFn.apply(decoratedSchema, args)
+            : (params) => addDecorators(decoratedSchema, [{ ref: decorator, params }]);
+        Object.defineProperty(decoratedSchema, decorator, { value, ...defaultZodDecoSchemaProperties });
+    }
+    if (!decoratedSchema.hasOwnProperty('addDecorators')) {
+        Object.defineProperty(decoratedSchema, 'addDecorators', {
+            value: (decorators) => addDecorators(decoratedSchema, decorators),
+            ...defaultZodDecoSchemaProperties
+        });
+    }
+    return decoratedSchema;
+}
+// =============================================================================
+// ADD DECORATORS
+// =============================================================================
+// -----------------------------------------------------------------------------
+// DB related decorators
+// -----------------------------------------------------------------------------
+export function addDBIndexed(schema) {
+    // Lazy initialization: ensure decorators are loaded
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [ZodDecorator.IS_DB_INDEXED]);
+}
+export function addForeignKey(schema) {
+    // Lazy initialization: ensure decorators are loaded
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [ZodDecorator.IS_FOREIGN_KEY]);
+}
+// -----------------------------------------------------------------------------
+// FORMS
+// -----------------------------------------------------------------------------
+// addFormInput, addFormTextarea, addFormSelect, etc. — removed.
+// Component selection moved to {primitive}UI({ edit: { component } }).
+export function addHidden(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_HIDDEN, params }]);
+}
+export function addNotEditable(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_NOT_EDITABLE, params }]);
+}
+export function addSortable(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.ARRAY_UI, params: { edit: { isSortable: true, ...params } } }]);
+}
+// -----------------------------------------------------------------------------
+// NEW DECORATOR ADD FUNCTIONS
+// -----------------------------------------------------------------------------
+export function addSummaryField(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_SUMMARY_FIELD, params }]);
+}
+export function addBackendOnly(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_BACKEND_ONLY, params }]);
+}
+export function addVirtual(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_VIRTUAL, params }]);
+}
+export function addDiscriminator(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_DISCRIMINATOR, params }]);
+}
+export function addExcludeFromCreate(schema) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [ZodDecorator.EXCLUDE_FROM_CREATE]);
+}
+export function addExcludeFromUpdate(schema) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [ZodDecorator.EXCLUDE_FROM_UPDATE]);
+}
+export function addUnique(schema, params) {
+    ensureZodDecoratorsLoaded(z);
+    return addDecorators(schema, [{ ref: ZodDecorator.IS_UNIQUE, params }]);
+}
+// -----------------------------------------------------------------------------
+// DECORATOR DETECTION HELPER FUNCTIONS
+// -----------------------------------------------------------------------------
+/**
+ * Recursively get metadata from a schema, traversing through wrapper types.
+ *
+ * Zod 4's methods like `partial()`, `required()`, `optional()`, `nullable()`, `default()`
+ * wrap the original schema in new types. The original decorated schema becomes the `innerType`.
+ * This function traverses through these wrappers to find the original metadata.
+ *
+ * Traversal order:
+ * 1. Check if metadata exists directly on the schema
+ * 2. If not found, check `_zod.def.innerType` recursively
+ *    (ZodOptional, ZodNullable, ZodDefault, ZodNonOptional, ZodReadonly, ZodCatch)
+ * 3. For ZodEffects (transforms), check `_zod.def.schema`
+ * 4. For ZodArray, check `_zod.def.element`
+ * 5. For ZodPipe (from .refine()/.superRefine()), check `_zod.def.in`
+ */
+export function getMetadataRecursive(schema) {
+    if (!schema)
+        return undefined;
+    // First check directly on this schema
+    const directMetadata = schema[SCHEMA_METADATA];
+    if (directMetadata && Object.keys(directMetadata).length > 0) {
+        return directMetadata;
+    }
+    // Access the internal Zod definition
+    const def = schema._zod?.def;
+    if (!def)
+        return undefined;
+    // Traverse through wrapper types that use innerType:
+    // ZodOptional, ZodNullable, ZodDefault, ZodNonOptional, ZodReadonly, ZodCatch
+    if (def.innerType) {
+        return getMetadataRecursive(def.innerType);
+    }
+    // ZodEffects (transforms) have a schema property
+    if (def.schema) {
+        return getMetadataRecursive(def.schema);
+    }
+    // ZodArray has element
+    if (def.element) {
+        return getMetadataRecursive(def.element);
+    }
+    // ZodPipe (from .refine()/.superRefine()) has 'in' for the input schema
+    if (def.in) {
+        return getMetadataRecursive(def.in);
+    }
+    return undefined;
+}
+// Reader functions (is*, get*Params, etc.) are consolidated in zod-utils.shared.ts.
+// Only writers (add*), getMetadataRecursive, and addPrimaryKey remain here.
+/**
+ * Apply isPrimaryKey decorator to a schema (composite: excludeFromCreate + isHidden + isUnique + isDBIndexed).
+ */
+export function addPrimaryKey(schema) {
+    return addDecorators(schema, [
+        ZodDecorator.IS_PRIMARY_KEY,
+        ZodDecorator.EXCLUDE_FROM_CREATE,
+        ZodDecorator.IS_HIDDEN,
+        ZodDecorator.IS_DB_INDEXED,
+        { ref: ZodDecorator.IS_UNIQUE, params: { scope: 'global', sparse: false } },
+    ]);
+}
+/**
+ * Helper to create a metadata-preserving wrapper for Zod methods that return new instances.
+ * In Zod v4, methods like .min(), .max(), etc. return NEW schema instances,
+ * which would lose our SCHEMA_METADATA Symbol. This wrapper copies the metadata.
+ */
+function wrapMethodToPreserveMetadata(originalMethod, methodName) {
+    return function (...args) {
+        const originalMetadata = this[SCHEMA_METADATA];
+        const result = originalMethod.apply(this, args);
+        // Copy all metadata from original (this) to result if it exists
+        // This includes rangeConfig and currencyConfig which are now part of SCHEMA_METADATA
+        if (originalMetadata && Object.keys(originalMetadata).length > 0 && result && result !== this) {
+            result[SCHEMA_METADATA] = { ...originalMetadata };
+        }
+        return result;
+    };
+}
+/**
+ * Patches all methods on a prototype that might return new instances,
+ * ensuring SCHEMA_METADATA is preserved through method chains.
+ */
+function patchPrototypeMethodsForMetadataPreservation(prototype, methodNames) {
+    for (const methodName of methodNames) {
+        const originalMethod = prototype[methodName];
+        if (typeof originalMethod === 'function') {
+            prototype[methodName] = wrapMethodToPreserveMetadata(originalMethod, methodName);
+        }
+    }
+}
+/**
+ * Ensures Zod decorators are applied to a specific Zod instance.
+ * This is critical when multiple Zod instances exist in the dependency tree.
+ * Call this function early in your application startup to ensure decorators work.
+ *
+ * In Zod v4, many methods return new schema instances (for immutability).
+ * We patch these methods to copy SCHEMA_METADATA so decorators survive method chains.
+ *
+ * @param zodInstance - The Zod instance to apply decorators to (defaults to the imported 'z')
+ * @returns true if decorators were already present, false if they were just applied
+ */
+export function ensureZodDecoratorsLoaded(zodInstance = z) {
+    // @ts-ignore - Dynamic property access for decorator checking
+    const zi = zodInstance;
+    // Check if decorators are already applied
+    const alreadyLoaded = typeof zodInstance.ZodString.prototype[ZodDecorator.IS_DB_INDEXED] === 'function';
+    if (alreadyLoaded) {
+        return zodInstance;
+    }
+    // =============================================================================
+    // STEP 1: Patch Zod methods to preserve SCHEMA_METADATA through method chains
+    // =============================================================================
+    // ZodString methods that return new instances in Zod v4
+    const zodStringMethodsToWrap = [
+        'min', 'max', 'length', 'email', 'url', 'uuid', 'nanoid', 'cuid', 'cuid2', 'ulid',
+        'regex', 'includes', 'startsWith', 'endsWith', 'datetime', 'date', 'time', 'duration',
+        'ip', 'base64', 'trim', 'toLowerCase', 'toUpperCase', 'jwt', 'emoji',
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodString.prototype, zodStringMethodsToWrap);
+    // ZodNumber methods that return new instances
+    const zodNumberMethodsToWrap = [
+        'min', 'max', 'int', 'positive', 'negative', 'nonnegative', 'nonpositive',
+        'multipleOf', 'finite', 'safe', 'step',
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodNumber.prototype, zodNumberMethodsToWrap);
+    // ZodDate methods that return new instances
+    const zodDateMethodsToWrap = [
+        'min', 'max',
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodDate.prototype, zodDateMethodsToWrap);
+    // ZodBoolean methods
+    const zodBooleanMethodsToWrap = [
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodBoolean.prototype, zodBooleanMethodsToWrap);
+    // ZodArray methods
+    const zodArrayMethodsToWrap = [
+        'min', 'max', 'length', 'nonempty',
+        'optional', 'nullable', 'nullish', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodArray.prototype, zodArrayMethodsToWrap);
+    // ZodEnum methods
+    const zodEnumMethodsToWrap = [
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodEnum.prototype, zodEnumMethodsToWrap);
+    // ZodOptional methods
+    const zodOptionalMethodsToWrap = [
+        'optional', 'nullable', 'nullish', 'array', 'or', 'and', 'transform', 'default',
+        'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+    ];
+    patchPrototypeMethodsForMetadataPreservation(zodInstance.ZodOptional.prototype, zodOptionalMethodsToWrap);
+    // =============================================================================
+    // STEP 2: Apply decorator methods to Zod prototypes
+    // =============================================================================
+    // Apply decorators to this Zod instance
+    zodInstance.ZodString.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    // New decorators
+    zodInstance.ZodString.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+    zodInstance.ZodString.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodString.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // Database constraint decorators
+    zodInstance.ZodString.prototype[ZodDecorator.IS_UNIQUE] = ZodDecorator_FunctionType[ZodDecorator.IS_UNIQUE];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_PRIMARY_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_PRIMARY_KEY];
+    // String edit mode convenience decorators
+    zodInstance.ZodString.prototype[ZodDecorator.IS_PASSWORD] = ZodDecorator_FunctionType[ZodDecorator.IS_PASSWORD];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_OTP] = ZodDecorator_FunctionType[ZodDecorator.IS_OTP];
+    zodInstance.ZodString.prototype[ZodDecorator.IS_COLOR] = ZodDecorator_FunctionType[ZodDecorator.IS_COLOR];
+    // Ephemeral field decorator
+    zodInstance.ZodString.prototype[ZodDecorator.IS_EPHEMERAL] = ZodDecorator_FunctionType[ZodDecorator.IS_EPHEMERAL];
+    // CRDT field decorator
+    zodInstance.ZodString.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorator
+    zodInstance.ZodString.prototype[ZodDecorator.STRING_UI] = ZodDecorator_FunctionType[ZodDecorator.STRING_UI];
+    zodInstance.ZodString.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    // New decorators
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+    zodInstance.ZodNumber.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodNumber.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // Database constraint decorators
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_UNIQUE] = ZodDecorator_FunctionType[ZodDecorator.IS_UNIQUE];
+    // CRDT field decorator
+    zodInstance.ZodNumber.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorator
+    zodInstance.ZodNumber.prototype[ZodDecorator.NUMBER_UI] = ZodDecorator_FunctionType[ZodDecorator.NUMBER_UI];
+    zodInstance.ZodNumber.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    // New decorators
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodBoolean.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // CRDT field decorator
+    zodInstance.ZodBoolean.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorator
+    zodInstance.ZodBoolean.prototype[ZodDecorator.BOOLEAN_UI] = ZodDecorator_FunctionType[ZodDecorator.BOOLEAN_UI];
+    zodInstance.ZodBoolean.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    // New decorators
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodDate.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodDate.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // TTL decorator for MongoDB TTL indexes (automatic document expiration)
+    zodInstance.ZodDate.prototype[ZodDecorator.TTL] = ZodDecorator_FunctionType[ZodDecorator.TTL];
+    // CRDT field decorator
+    zodInstance.ZodDate.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorator
+    zodInstance.ZodDate.prototype[ZodDecorator.DATE_UI] = ZodDecorator_FunctionType[ZodDecorator.DATE_UI];
+    zodInstance.ZodDate.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    zodInstance.ZodOptional.prototype[ZodDecorator.SYSTEM_ENUM] = ZodDecorator_FunctionType[ZodDecorator.SYSTEM_ENUM];
+    // New decorators
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+    zodInstance.ZodOptional.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodOptional.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // Database constraint decorators - optional wrapper types need isUnique for z.string().isUnique().optional() pattern
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_UNIQUE] = ZodDecorator_FunctionType[ZodDecorator.IS_UNIQUE];
+    // Ephemeral field decorator
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_EPHEMERAL] = ZodDecorator_FunctionType[ZodDecorator.IS_EPHEMERAL];
+    // CRDT field decorator
+    zodInstance.ZodOptional.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorators (ZodOptional wraps any primitive)
+    zodInstance.ZodOptional.prototype[ZodDecorator.BOOLEAN_UI] = ZodDecorator_FunctionType[ZodDecorator.BOOLEAN_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.STRING_UI] = ZodDecorator_FunctionType[ZodDecorator.STRING_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.NUMBER_UI] = ZodDecorator_FunctionType[ZodDecorator.NUMBER_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.ENUM_UI] = ZodDecorator_FunctionType[ZodDecorator.ENUM_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.DATE_UI] = ZodDecorator_FunctionType[ZodDecorator.DATE_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.ARRAY_UI] = ZodDecorator_FunctionType[ZodDecorator.ARRAY_UI];
+    zodInstance.ZodOptional.prototype[ZodDecorator.OBJECT_UI] = ZodDecorator_FunctionType[ZodDecorator.OBJECT_UI];
+    zodInstance.ZodOptional.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    zodInstance.ZodEnum.prototype[ZodDecorator.SYSTEM_ENUM] = ZodDecorator_FunctionType[ZodDecorator.SYSTEM_ENUM];
+    // New decorators
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+    zodInstance.ZodEnum.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodEnum.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // CRDT field decorator
+    zodInstance.ZodEnum.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    // Unified UI decorator
+    zodInstance.ZodEnum.prototype[ZodDecorator.ENUM_UI] = ZodDecorator_FunctionType[ZodDecorator.ENUM_UI];
+    zodInstance.ZodEnum.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+    zodInstance.ZodArray.prototype[ZodDecorator.ARRAY_UI] = ZodDecorator_FunctionType[ZodDecorator.ARRAY_UI];
+    zodInstance.ZodArray.prototype.isSortable = ZodDecorator_FunctionType['isSortable'];
+    // New decorators
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+    zodInstance.ZodArray.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+    zodInstance.ZodArray.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+    // CRDT field decorator
+    zodInstance.ZodArray.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+    zodInstance.ZodArray.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    // Wrapper types (ZodDefault, ZodNullable) need ALL decorators for chaining
+    // e.g. z.date().default(...).excludeFromCreate().isNotEditable().showWhen(...)
+    for (const wrapperName of ['ZodDefault', 'ZodNullable']) {
+        const wrapperCtor = zi[wrapperName];
+        if (wrapperCtor?.prototype) {
+            patchPrototypeMethodsForMetadataPreservation(wrapperCtor.prototype, zodOptionalMethodsToWrap);
+            for (const [key, fn] of Object.entries(ZodDecorator_FunctionType)) {
+                wrapperCtor.prototype[key] = fn;
+            }
+            wrapperCtor.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+        }
+    }
+    // ZodUnion wrapper type - needs decorators for union fields
+    if (zi.ZodUnion?.prototype) {
+        patchPrototypeMethodsForMetadataPreservation(zi.ZodUnion.prototype, zodOptionalMethodsToWrap);
+        zi.ZodUnion.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+        zi.ZodUnion.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+        zi.ZodUnion.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+        zi.ZodUnion.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+        zi.ZodUnion.prototype[ZodDecorator.SYSTEM_ENUM] = ZodDecorator_FunctionType[ZodDecorator.SYSTEM_ENUM];
+        // New decorators
+        zi.ZodUnion.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+        zi.ZodUnion.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+        zi.ZodUnion.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+        zi.ZodUnion.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+        zi.ZodUnion.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+        zi.ZodUnion.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+        // CRDT field decorator
+        zi.ZodUnion.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+        zi.ZodUnion.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    }
+    // Object / record decorators
+    if (zi.ZodObject?.prototype) {
+        zi.ZodObject.prototype[ZodDecorator.OBJECT_UI] = ZodDecorator_FunctionType[ZodDecorator.OBJECT_UI];
+        zi.ZodObject.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+        zi.ZodObject.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+        zi.ZodObject.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+        zi.ZodObject.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+        zi.ZodObject.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+        // CRDT field decorator
+        zi.ZodObject.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+        zi.ZodObject.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    }
+    if (zi.ZodRecord?.prototype) {
+        zi.ZodRecord.prototype[ZodDecorator.OBJECT_UI] = ZodDecorator_FunctionType[ZodDecorator.OBJECT_UI];
+        // New decorators
+        zi.ZodRecord.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+        zi.ZodRecord.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+        zi.ZodRecord.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+        zi.ZodRecord.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+        zi.ZodRecord.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+        // CRDT field decorator
+        zi.ZodRecord.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+        zi.ZodRecord.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    }
+    // Add support for ZodMap if available
+    if (zi.ZodMap?.prototype) {
+        patchPrototypeMethodsForMetadataPreservation(zi.ZodMap.prototype, [
+            'optional', 'nullable', 'nullish', 'or', 'and', 'transform', 'default',
+            'catch', 'describe', 'brand', 'readonly', 'pipe', 'refine', 'superRefine'
+        ]);
+        zi.ZodMap.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+        zi.ZodMap.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+        zi.ZodMap.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+        zi.ZodMap.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+        zi.ZodMap.prototype[ZodDecorator.OBJECT_UI] = ZodDecorator_FunctionType[ZodDecorator.OBJECT_UI];
+        // New decorators
+        zi.ZodMap.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+        zi.ZodMap.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+        zi.ZodMap.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+        zi.ZodMap.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+        zi.ZodMap.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+        // CRDT field decorator
+        zi.ZodMap.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+        zi.ZodMap.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+    }
+    // Helper function to add decorators to Zod string refinement types
+    function addDecoratorsToZodStringRefinement(constructorName) {
+        const Candidate = zi[constructorName];
+        if (Candidate && typeof Candidate === 'object' && 'prototype' in Candidate) {
+            const Constructor = Candidate;
+            // Patch methods first, then add decorators
+            patchPrototypeMethodsForMetadataPreservation(Constructor.prototype, zodStringMethodsToWrap);
+            Constructor.prototype[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+            Constructor.prototype[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+            Constructor.prototype[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+            Constructor.prototype[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+            // New decorators
+            Constructor.prototype[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+            Constructor.prototype[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+            Constructor.prototype[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+            Constructor.prototype[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+            Constructor.prototype[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+            Constructor.prototype[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+            // Database constraint decorators - format validators like email/uuid are commonly used as unique identifiers
+            Constructor.prototype[ZodDecorator.IS_UNIQUE] = ZodDecorator_FunctionType[ZodDecorator.IS_UNIQUE];
+            // Ephemeral field decorator
+            Constructor.prototype[ZodDecorator.IS_EPHEMERAL] = ZodDecorator_FunctionType[ZodDecorator.IS_EPHEMERAL];
+            // CRDT field decorator
+            Constructor.prototype[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+            Constructor.prototype.addDecorators = ZodDecorator_FunctionAddDecorators;
+        }
+    }
+    // Add decorator support to Zod string refinement types
+    addDecoratorsToZodStringRefinement('ZodEmail');
+    addDecoratorsToZodStringRefinement('ZodUUID');
+    addDecoratorsToZodStringRefinement('ZodURL');
+    addDecoratorsToZodStringRefinement('ZodHttpUrl');
+    addDecoratorsToZodStringRefinement('ZodHostname');
+    addDecoratorsToZodStringRefinement('ZodEmoji');
+    addDecoratorsToZodStringRefinement('ZodBase64');
+    addDecoratorsToZodStringRefinement('ZodBase64Url');
+    addDecoratorsToZodStringRefinement('ZodHex');
+    addDecoratorsToZodStringRefinement('ZodJWT');
+    addDecoratorsToZodStringRefinement('ZodNanoId');
+    addDecoratorsToZodStringRefinement('ZodCuid');
+    addDecoratorsToZodStringRefinement('ZodCuid2');
+    addDecoratorsToZodStringRefinement('ZodULID');
+    addDecoratorsToZodStringRefinement('ZodIPv4');
+    addDecoratorsToZodStringRefinement('ZodIPv6');
+    addDecoratorsToZodStringRefinement('ZodMac');
+    addDecoratorsToZodStringRefinement('ZodCidrV4');
+    addDecoratorsToZodStringRefinement('ZodCidrV6');
+    addDecoratorsToZodStringRefinement('ZodHash');
+    addDecoratorsToZodStringRefinement('ZodISODate');
+    addDecoratorsToZodStringRefinement('ZodISOTime');
+    addDecoratorsToZodStringRefinement('ZodISODatetime');
+    addDecoratorsToZodStringRefinement('ZodISODateTime');
+    addDecoratorsToZodStringRefinement('ZodISODuration');
+    // =============================================================================
+    // STEP 3: Dynamically patch format validator prototypes
+    // In Zod 4, z.email(), z.url() etc. may return schemas whose constructors
+    // aren't exposed on the z namespace. We discover them by creating instances.
+    // =============================================================================
+    const patchedPrototypes = new Set();
+    function patchFormatValidatorPrototype(factoryFn) {
+        try {
+            const schema = factoryFn();
+            const proto = Object.getPrototypeOf(schema);
+            // Skip if already patched or if it's ZodString (already handled)
+            if (!proto || patchedPrototypes.has(proto))
+                return;
+            if (proto === zodInstance.ZodString.prototype)
+                return;
+            // Check if already has decorators
+            if (typeof proto[ZodDecorator.IS_DB_INDEXED] === 'function') {
+                patchedPrototypes.add(proto);
+                return;
+            }
+            // Patch this prototype
+            patchPrototypeMethodsForMetadataPreservation(proto, zodStringMethodsToWrap);
+            proto[ZodDecorator.IS_DB_INDEXED] = ZodDecorator_FunctionType[ZodDecorator.IS_DB_INDEXED];
+            proto[ZodDecorator.IS_FOREIGN_KEY] = ZodDecorator_FunctionType[ZodDecorator.IS_FOREIGN_KEY];
+            proto[ZodDecorator.IS_HIDDEN] = ZodDecorator_FunctionType[ZodDecorator.IS_HIDDEN];
+            proto[ZodDecorator.IS_NOT_EDITABLE] = ZodDecorator_FunctionType[ZodDecorator.IS_NOT_EDITABLE];
+            // New decorators
+            proto[ZodDecorator.IS_SUMMARY_FIELD] = ZodDecorator_FunctionType[ZodDecorator.IS_SUMMARY_FIELD];
+            proto[ZodDecorator.IS_BACKEND_ONLY] = ZodDecorator_FunctionType[ZodDecorator.IS_BACKEND_ONLY];
+            proto[ZodDecorator.IS_VIRTUAL] = ZodDecorator_FunctionType[ZodDecorator.IS_VIRTUAL];
+            proto[ZodDecorator.IS_DISCRIMINATOR] = ZodDecorator_FunctionType[ZodDecorator.IS_DISCRIMINATOR];
+            proto[ZodDecorator.EXCLUDE_FROM_CREATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_CREATE];
+            proto[ZodDecorator.EXCLUDE_FROM_UPDATE] = ZodDecorator_FunctionType[ZodDecorator.EXCLUDE_FROM_UPDATE];
+            // Database constraint decorators - format validators like email/uuid are commonly used as unique identifiers
+            proto[ZodDecorator.IS_UNIQUE] = ZodDecorator_FunctionType[ZodDecorator.IS_UNIQUE];
+            // Format validators like uuid/email/url are still string-backed primitives,
+            // so platform presets must be able to apply string display/edit policies.
+            proto[ZodDecorator.STRING_UI] = ZodDecorator_FunctionType[ZodDecorator.STRING_UI];
+            // Ephemeral field decorator
+            proto[ZodDecorator.IS_EPHEMERAL] = ZodDecorator_FunctionType[ZodDecorator.IS_EPHEMERAL];
+            // CRDT field decorator
+            proto[ZodDecorator.IS_CRDT] = ZodDecorator_FunctionType[ZodDecorator.IS_CRDT];
+            proto.addDecorators = ZodDecorator_FunctionAddDecorators;
+            patchedPrototypes.add(proto);
+        }
+        catch {
+            // Factory function might not exist in this Zod version
+        }
+    }
+    // Patch all format validators by creating instances
+    patchFormatValidatorPrototype(() => zodInstance.email());
+    patchFormatValidatorPrototype(() => zodInstance.url());
+    patchFormatValidatorPrototype(() => zodInstance.uuid());
+    patchFormatValidatorPrototype(() => zodInstance.cuid());
+    patchFormatValidatorPrototype(() => zodInstance.cuid2());
+    patchFormatValidatorPrototype(() => zodInstance.ulid());
+    patchFormatValidatorPrototype(() => zodInstance.nanoid());
+    patchFormatValidatorPrototype(() => zodInstance.base64());
+    patchFormatValidatorPrototype(() => zodInstance.jwt());
+    patchFormatValidatorPrototype(() => zodInstance.emoji());
+    patchFormatValidatorPrototype(() => zodInstance.ipv4());
+    patchFormatValidatorPrototype(() => zodInstance.ipv6());
+    patchFormatValidatorPrototype(() => zodInstance.cidrv4());
+    patchFormatValidatorPrototype(() => zodInstance.cidrv6());
+    // Patch z.iso.* format validators
+    patchFormatValidatorPrototype(() => zodInstance.iso.datetime());
+    patchFormatValidatorPrototype(() => zodInstance.iso.date());
+    patchFormatValidatorPrototype(() => zodInstance.iso.time());
+    patchFormatValidatorPrototype(() => zodInstance.iso.duration());
+    // Note: z.range() is exported as standalone `z_range()` function.
+    return zodInstance;
+}
+// Extend the Zod prototypes with the decorator methods (apply to the default imported instance)
+ensureZodDecoratorsLoaded(z);
+//# sourceMappingURL=zod.module-override.js.map