ont-run 0.0.5 → 0.0.6

package/dist/src/config/define.d.ts

@@ -38,7 +38,7 @@ import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, Environment
  * });
  * ```
  */
-export declare function defineOntology<TGroups extends string, TEntities extends string, TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities>>>(config: {
+export declare function defineOntology<TGroups extends string, TEntities extends string, TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities, any, any>>>(config: {
     name: string;
     environments: Record<string, EnvironmentConfig>;
     auth: AuthFunction;

package/dist/src/config/schema.d.ts

@@ -5,60 +5,30 @@ import type { OntologyConfig } from "./types.js";
  */
 export declare const EnvironmentConfigSchema: z.ZodObject<{
     debug: z.ZodOptional<z.ZodBoolean>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    debug: z.ZodOptional<z.ZodBoolean>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    debug: z.ZodOptional<z.ZodBoolean>;
-}, z.ZodTypeAny, "passthrough">>;
+}, z.core.$loose>;
 /**
  * Schema for access group configuration
  */
 export declare const AccessGroupConfigSchema: z.ZodObject<{
     description: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-}, {
-    description: string;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for entity definition
  */
 export declare const EntityDefinitionSchema: z.ZodObject<{
     description: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-}, {
-    description: string;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for function definition
  */
 export declare const FunctionDefinitionSchema: z.ZodObject<{
     description: z.ZodString;
-    access: z.ZodArray<z.ZodString, "many">;
-    entities: z.ZodArray<z.ZodString, "many">;
-    inputs: z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>;
-    outputs: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
-    resolver: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    access: string[];
-    entities: string[];
-    inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: (...args: unknown[]) => unknown;
-    outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-}, {
-    description: string;
-    access: string[];
-    entities: string[];
-    inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: (...args: unknown[]) => unknown;
-    outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-}>;
-/**
- * Schema for auth function
- */
-export declare const AuthFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<Request, z.ZodTypeDef, Request>], z.ZodUnknown>, z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodPromise<z.ZodArray<z.ZodString, "many">>]>>;
+    access: z.ZodArray<z.ZodString>;
+    entities: z.ZodArray<z.ZodString>;
+    inputs: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    outputs: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    resolver: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+}, z.core.$strip>;
 /**
  * Schema for the full ontology configuration
  */
@@ -66,89 +36,23 @@ export declare const OntologyConfigSchema: z.ZodObject<{
     name: z.ZodString;
     environments: z.ZodRecord<z.ZodString, z.ZodObject<{
         debug: z.ZodOptional<z.ZodBoolean>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        debug: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        debug: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>>;
-    auth: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+    }, z.core.$loose>>;
+    auth: z.ZodCustom<(req: Request) => unknown, (req: Request) => unknown>;
     accessGroups: z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-    }, {
-        description: string;
-    }>>;
+    }, z.core.$strip>>;
     entities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-    }, {
-        description: string;
-    }>>>;
+    }, z.core.$strip>>>;
     functions: z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodString;
-        access: z.ZodArray<z.ZodString, "many">;
-        entities: z.ZodArray<z.ZodString, "many">;
-        inputs: z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>;
-        outputs: z.ZodOptional<z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>>;
-        resolver: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: (...args: unknown[]) => unknown;
-        outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-    }, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: (...args: unknown[]) => unknown;
-        outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    environments: Record<string, z.objectOutputType<{
-        debug: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>;
-    auth: (...args: unknown[]) => unknown;
-    accessGroups: Record<string, {
-        description: string;
-    }>;
-    functions: Record<string, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: (...args: unknown[]) => unknown;
-        outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-    }>;
-    entities?: Record<string, {
-        description: string;
-    }> | undefined;
-}, {
-    name: string;
-    environments: Record<string, z.objectInputType<{
-        debug: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>;
-    auth: (...args: unknown[]) => unknown;
-    accessGroups: Record<string, {
-        description: string;
-    }>;
-    functions: Record<string, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: (...args: unknown[]) => unknown;
-        outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-    }>;
-    entities?: Record<string, {
-        description: string;
-    }> | undefined;
-}>;
+        access: z.ZodArray<z.ZodString>;
+        entities: z.ZodArray<z.ZodString>;
+        inputs: z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        outputs: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        resolver: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 /**
  * Validate that all function access groups exist in accessGroups
  */

package/dist/src/config/zod-utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Utility functions for inspecting Zod schemas.
+ * These use duck typing to work across Zod 3 and Zod 4.
+ */
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries and Zod versions)
+ */
+export declare function isZodSchema(val: unknown): boolean;
+/**
+ * Get the Zod type name from a schema (works with both Zod 3 and 4)
+ */
+export declare function getZodTypeName(schema: unknown): string | undefined;
+/**
+ * Check if schema is a ZodObject (works with both Zod 3 and 4)
+ */
+export declare function isZodObject(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodOptional (works with both Zod 3 and 4)
+ */
+export declare function isZodOptional(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodNullable (works with both Zod 3 and 4)
+ */
+export declare function isZodNullable(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodArray (works with both Zod 3 and 4)
+ */
+export declare function isZodArray(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodDefault (works with both Zod 3 and 4)
+ */
+export declare function isZodDefault(schema: unknown): boolean;
+/**
+ * Get the shape of a ZodObject schema (works with both Zod 3 and 4)
+ */
+export declare function getObjectShape(schema: unknown): Record<string, unknown> | undefined;
+/**
+ * Get the inner schema from Optional/Nullable/Default (works with both Zod 3 and 4)
+ */
+export declare function getInnerSchema(schema: unknown): unknown;
+/**
+ * Get the element schema from a ZodArray (works with both Zod 3 and 4)
+ */
+export declare function getArrayElement(schema: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Ontology-enforced API framework for AI coding agents",
   "type": "module",
   "bin": {
@@ -35,8 +35,7 @@
     "consola": "^3.2.0",
     "hono": "^4.6.0",
     "open": "^10.0.0",
-    "zod": "^3.24.0",
-    "zod-to-json-schema": "^3.23.0"
+    "zod": "4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/browser/transform.ts

@@ -1,8 +1,17 @@
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import type { OntologyConfig } from "../config/types.js";
 import type { OntologyDiff, FunctionChange } from "../lockfile/types.js";
 import { getFieldFromMetadata, getUserContextFields } from "../config/categorical.js";
+import {
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "../config/zod-utils.js";
 
 export type NodeType = "entity" | "function" | "accessGroup";
 export type EdgeType = "operates-on" | "requires-access" | "depends-on";
@@ -80,30 +89,44 @@ function extractFieldReferences(
     });
   }
 
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldReferences(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldReferences(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
-  if (schema instanceof z.ZodDefault) {
-    results.push(...extractFieldReferences(schema._def.innerType, path));
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;
@@ -114,7 +137,7 @@ function extractFieldReferences(
  */
 function safeZodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> | undefined {
   try {
-    const result = zodToJsonSchema(schema, { $refStrategy: "none" }) as Record<string, unknown>;
+    const result = z.toJSONSchema(schema, { reused: "inline", unrepresentable: "any" }) as Record<string, unknown>;
     delete result.$schema;
     return result;
   } catch {

package/src/cli/commands/init.ts

@@ -54,6 +54,11 @@ export const initCommand = defineCommand({
     const configTemplate = `import { defineOntology, userContext } from 'ont-run';
 import { z } from 'zod';
 
+// Import resolver functions - TypeScript enforces return types match outputs
+import healthCheck from './resolvers/healthCheck.js';
+import getUser from './resolvers/getUser.js';
+import deleteUser from './resolvers/deleteUser.js';
+
 export default defineOntology({
   name: 'my-api',
 
@@ -98,7 +103,7 @@ export default defineOntology({
       access: ['public', 'support', 'admin'],
       entities: [],
       inputs: z.object({}),
-      resolver: './resolvers/healthCheck.ts',
+      resolver: healthCheck,
     },
 
     // Example: Restricted function with row-level access
@@ -114,7 +119,7 @@ export default defineOntology({
           email: z.string(),
         })),
       }),
-      resolver: './resolvers/getUser.ts',
+      resolver: getUser,
     },
 
     // Example: Admin-only function
@@ -126,7 +131,7 @@ export default defineOntology({
         userId: z.string().uuid(),
         reason: z.string().optional(),
       }),
-      resolver: './resolvers/deleteUser.ts',
+      resolver: deleteUser,
     },
   },
 });
@@ -138,7 +143,7 @@ export default defineOntology({
     // Write example resolvers
     const healthCheckResolver = `import type { ResolverContext } from 'ont-run';
 
-export default async function healthCheck(ctx: ResolverContext, args: {}) {
+export default async function healthCheck(ctx: ResolverContext) {
   ctx.logger.info('Health check called');
 
   return {
@@ -237,7 +242,7 @@ await startOnt();
     packageJson.dependencies = {
       ...(packageJson.dependencies as Record<string, string> || {}),
       "ont-run": "latest",
-      zod: "^3.24.0",
+      zod: "^4.0.0",
     };
 
     writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));

package/src/config/define.ts

@@ -56,7 +56,9 @@ import type {
 export function defineOntology<
   TGroups extends string,
   TEntities extends string,
-  TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities>>,
+  // Use `any` for input/output schema types to avoid contravariance issues with resolver functions.
+  // Without this, ResolverFunction<unknown, unknown> won't accept more specific resolver types.
+  TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities, any, any>>,
 >(config: {
   name: string;
   environments: Record<string, EnvironmentConfig>;

package/src/config/schema.ts

@@ -1,5 +1,16 @@
 import { z } from "zod";
 import { getFieldFromMetadata, getUserContextFields } from "./categorical.js";
+import {
+  isZodSchema,
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "./zod-utils.js";
 import type { OntologyConfig } from "./types.js";
 
 /**
@@ -26,16 +37,10 @@ export const EntityDefinitionSchema = z.object({
 });
 
 /**
- * Check if a value is a Zod schema (duck typing to work across bundle boundaries)
+ * Check if a value is a function
  */
-function isZodSchema(val: unknown): boolean {
-  return (
-    val !== null &&
-    typeof val === "object" &&
-    "_def" in val &&
-    "safeParse" in val &&
-    typeof (val as { safeParse: unknown }).safeParse === "function"
-  );
+function isFunction(val: unknown): val is (...args: unknown[]) => unknown {
+  return typeof val === "function";
 }
 
 /**
@@ -53,24 +58,20 @@ export const FunctionDefinitionSchema = z.object({
       message: "outputs must be a Zod schema",
     })
     .optional(),
-  resolver: z.function(),
+  resolver: z.custom<(...args: unknown[]) => unknown>(isFunction, {
+    message: "resolver must be a function",
+  }),
 });
 
-/**
- * Schema for auth function
- */
-export const AuthFunctionSchema = z
-  .function()
-  .args(z.custom<Request>())
-  .returns(z.union([z.array(z.string()), z.promise(z.array(z.string()))]));
-
 /**
  * Schema for the full ontology configuration
  */
 export const OntologyConfigSchema = z.object({
   name: z.string().min(1),
   environments: z.record(z.string(), EnvironmentConfigSchema),
-  auth: z.function(),
+  auth: z.custom<(req: Request) => unknown>(isFunction, {
+    message: "auth must be a function",
+  }),
   accessGroups: z.record(z.string(), AccessGroupConfigSchema),
   entities: z.record(z.string(), EntityDefinitionSchema).optional(),
   functions: z.record(z.string(), FunctionDefinitionSchema),
@@ -141,34 +142,48 @@ function extractFieldFromRefs(
   }
 
   // Handle ZodObject - recurse into properties
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldFromRefs(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldFromRefs(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
   // Handle ZodOptional - unwrap
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldFromRefs(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldFromRefs(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodNullable - unwrap
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldFromRefs(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldFromRefs(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodArray - recurse into element
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldFromRefs(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldFromRefs(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
   // Handle ZodDefault - unwrap
-  if (schema instanceof z.ZodDefault) {
-    results.push(...extractFieldFromRefs(schema._def.innerType, path));
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldFromRefs(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;

package/src/config/zod-utils.ts

@@ -0,0 +1,144 @@
+/**
+ * Utility functions for inspecting Zod schemas.
+ * These use duck typing to work across Zod 3 and Zod 4.
+ */
+
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries and Zod versions)
+ */
+export function isZodSchema(val: unknown): boolean {
+  if (val === null || typeof val !== "object") return false;
+  // Zod 4 uses _zod property
+  if ("_zod" in val && "safeParse" in val) return true;
+  // Zod 3 uses _def property
+  if ("_def" in val && "safeParse" in val) return true;
+  return false;
+}
+
+/**
+ * Get the Zod type name from a schema (works with both Zod 3 and 4)
+ */
+export function getZodTypeName(schema: unknown): string | undefined {
+  if (!isZodSchema(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: check _zod.def.typeName
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (typeof def.typeName === "string") return def.typeName;
+    }
+  }
+  // Zod 3: check _def.typeName
+  if (s._def && typeof s._def === "object") {
+    const def = s._def as Record<string, unknown>;
+    if (typeof def.typeName === "string") return def.typeName;
+  }
+  return undefined;
+}
+
+/**
+ * Check if schema is a ZodObject (works with both Zod 3 and 4)
+ */
+export function isZodObject(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodObject" || typeName === "object";
+}
+
+/**
+ * Check if schema is a ZodOptional (works with both Zod 3 and 4)
+ */
+export function isZodOptional(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodOptional" || typeName === "optional";
+}
+
+/**
+ * Check if schema is a ZodNullable (works with both Zod 3 and 4)
+ */
+export function isZodNullable(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodNullable" || typeName === "nullable";
+}
+
+/**
+ * Check if schema is a ZodArray (works with both Zod 3 and 4)
+ */
+export function isZodArray(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodArray" || typeName === "array";
+}
+
+/**
+ * Check if schema is a ZodDefault (works with both Zod 3 and 4)
+ */
+export function isZodDefault(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodDefault" || typeName === "default";
+}
+
+/**
+ * Get the shape of a ZodObject schema (works with both Zod 3 and 4)
+ */
+export function getObjectShape(schema: unknown): Record<string, unknown> | undefined {
+  if (!isZodObject(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: shape is in _zod.def.shape
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.shape && typeof def.shape === "object") {
+        return def.shape as Record<string, unknown>;
+      }
+    }
+  }
+  // Zod 3: shape property directly on schema
+  if (typeof s.shape === "object" && s.shape !== null) {
+    return s.shape as Record<string, unknown>;
+  }
+  return undefined;
+}
+
+/**
+ * Get the inner schema from Optional/Nullable/Default (works with both Zod 3 and 4)
+ */
+export function getInnerSchema(schema: unknown): unknown {
+  const s = schema as Record<string, unknown>;
+  // Zod 4: innerType is in _zod.def.innerType
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.innerType) return def.innerType;
+    }
+  }
+  // Zod 3: unwrap method or _def.innerType
+  if (typeof s.unwrap === "function") {
+    return (s.unwrap as () => unknown)();
+  }
+  if (s._def && typeof s._def === "object") {
+    const def = s._def as Record<string, unknown>;
+    if (def.innerType) return def.innerType;
+  }
+  return undefined;
+}
+
+/**
+ * Get the element schema from a ZodArray (works with both Zod 3 and 4)
+ */
+export function getArrayElement(schema: unknown): unknown {
+  if (!isZodArray(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: element is in _zod.def.element
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.element) return def.element;
+    }
+  }
+  // Zod 3: element property directly on schema
+  if (s.element) return s.element;
+  return undefined;
+}