ont-run 0.0.5 → 0.0.7

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

@@ -132,7 +132,6 @@ export declare function hasUserContextMetadata(schema: unknown): schema is UserC
 /**
  * Get all userContext field names from a Zod object schema
  *
- * Note: Uses _def.typeName check instead of instanceof to work across
- * module boundaries in bundled CLI.
+ * Note: Uses zod-utils for bundler compatibility (instanceof fails across module boundaries)
  */
 export declare function getUserContextFields(schema: z.ZodType): string[];

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,48 @@
+/**
+ * Utility functions for inspecting Zod 4 schemas.
+ * These use duck typing to work across bundle boundaries.
+ */
+/**
+ * Check if a value is a Zod 3 schema (has _def but not _zod)
+ */
+export declare function isZod3Schema(val: unknown): boolean;
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries)
+ */
+export declare function isZodSchema(val: unknown): boolean;
+/**
+ * Get the Zod type name from a schema
+ */
+export declare function getZodTypeName(schema: unknown): string | undefined;
+/**
+ * Check if schema is a ZodObject
+ */
+export declare function isZodObject(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodOptional
+ */
+export declare function isZodOptional(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodNullable
+ */
+export declare function isZodNullable(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodArray
+ */
+export declare function isZodArray(schema: unknown): boolean;
+/**
+ * Check if schema is a ZodDefault
+ */
+export declare function isZodDefault(schema: unknown): boolean;
+/**
+ * Get the shape of a ZodObject schema
+ */
+export declare function getObjectShape(schema: unknown): Record<string, unknown> | undefined;
+/**
+ * Get the inner schema from Optional/Nullable/Default
+ */
+export declare function getInnerSchema(schema: unknown): unknown;
+/**
+ * Get the element schema from a ZodArray
+ */
+export declare function getArrayElement(schema: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Ontology-enforced API framework for AI coding agents",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   "scripts": {
     "dev": "bun run bin/ont.ts",
     "build": "bun build ./src/index.ts --outdir ./dist --target node",
-    "build:cli": "bun build ./bin/ont.ts --outfile ./dist/bin/ont.js --target node --external @modelcontextprotocol/sdk",
+    "build:cli": "bun build ./bin/ont.ts --outfile ./dist/bin/ont.js --target node --external @modelcontextprotocol/sdk --external zod",
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "prepublishOnly": "bun run build && bun run build:cli && bun run build:types",
     "docs": "cd docs && bun run dev",
@@ -34,16 +34,16 @@
     "citty": "^0.1.6",
     "consola": "^3.2.0",
     "hono": "^4.6.0",
-    "open": "^10.0.0",
-    "zod": "^3.24.0",
-    "zod-to-json-schema": "^3.23.0"
+    "open": "^10.0.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "typescript": "^5.5.0"
+    "typescript": "^5.5.0",
+    "zod": "^4.0.0"
   },
   "peerDependencies": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.0.0",
+    "zod": ">=4"
   },
   "peerDependenciesMeta": {
     "bun": {

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/categorical.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { isZodObject, getObjectShape } from "./zod-utils";
 
 /**
  * Symbol for storing fieldFrom metadata on Zod schemas
@@ -175,19 +176,18 @@ export function hasUserContextMetadata(
 /**
  * Get all userContext field names from a Zod object schema
  *
- * Note: Uses _def.typeName check instead of instanceof to work across
- * module boundaries in bundled CLI.
+ * Note: Uses zod-utils for bundler compatibility (instanceof fails across module boundaries)
  */
 export function getUserContextFields(schema: z.ZodType): string[] {
   const fields: string[] = [];
 
-  // Use _def.typeName check for bundler compatibility (instanceof fails across module boundaries)
-  const def = (schema as unknown as { _def?: { typeName?: string; shape?: () => Record<string, unknown> } })._def;
-  if (def?.typeName === "ZodObject" && typeof def.shape === "function") {
-    const shape = def.shape();
-    for (const [key, value] of Object.entries(shape)) {
-      if (hasUserContextMetadata(value)) {
-        fields.push(key);
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (hasUserContextMetadata(value)) {
+          fields.push(key);
+        }
       }
     }
   }

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,17 @@
 import { z } from "zod";
 import { getFieldFromMetadata, getUserContextFields } from "./categorical.js";
+import {
+  isZodSchema,
+  isZod3Schema,
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "./zod-utils.js";
 import type { OntologyConfig } from "./types.js";
 
 /**
@@ -26,16 +38,24 @@ 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";
+}
+
+/**
+ * Validate that a value is a Zod 4 schema, with helpful error for Zod 3
+ */
+function validateZodSchema(val: unknown, fieldName: string): boolean {
+  if (isZodSchema(val)) return true;
+  if (isZod3Schema(val)) {
+    throw new Error(
+      `${fieldName} appears to be a Zod 3 schema. ont-run requires Zod 4.\n` +
+      `Please upgrade: bun add zod@4`
+    );
+  }
+  return false;
 }
 
 /**
@@ -45,32 +65,28 @@ export const FunctionDefinitionSchema = z.object({
   description: z.string(),
   access: z.array(z.string()).min(1),
   entities: z.array(z.string()),
-  inputs: z.custom<z.ZodType>(isZodSchema, {
-    message: "inputs must be a Zod schema",
+  inputs: z.custom<z.ZodType>((val) => validateZodSchema(val, "inputs"), {
+    message: "inputs must be a Zod 4 schema",
   }),
   outputs: z
-    .custom<z.ZodType>(isZodSchema, {
-      message: "outputs must be a Zod schema",
+    .custom<z.ZodType>((val) => validateZodSchema(val, "outputs"), {
+      message: "outputs must be a Zod 4 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 +157,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;