ont-run 0.0.4 → 0.0.6

package/src/browser/server.ts

@@ -1,4 +1,6 @@
 import { Hono } from "hono";
+import { readFileSync } from "fs";
+import { basename } from "path";
 import open from "open";
 import type { OntologyConfig } from "../config/types.js";
 import type { OntologyDiff } from "../lockfile/types.js";
@@ -12,6 +14,8 @@ export interface BrowserServerOptions {
   diff?: OntologyDiff | null;
   /** Directory to write the lockfile to on approval */
   configDir?: string;
+  /** Path to the ontology.config.ts file */
+  configPath?: string;
   port?: number;
   openBrowser?: boolean;
 }
@@ -22,7 +26,7 @@ export interface BrowserServerResult {
 }
 
 export async function startBrowserServer(options: BrowserServerOptions): Promise<BrowserServerResult> {
-  const { config, diff = null, configDir, port: preferredPort, openBrowser = true } = options;
+  const { config, diff = null, configDir, configPath, port: preferredPort, openBrowser = true } = options;
 
   // Transform config to graph data and enhance with diff info
   const baseGraphData = transformToGraphData(config);
@@ -90,6 +94,26 @@ export async function startBrowserServer(options: BrowserServerOptions): Promise
       return c.json({ success: true });
     });
 
+    // API: Get raw TypeScript source
+    app.get("/api/source", (c) => {
+      if (!configPath) {
+        return c.json({ error: "Config path not available" }, 400);
+      }
+      try {
+        const source = readFileSync(configPath, "utf-8");
+        const filename = basename(configPath);
+        return c.json({ source, filename, path: configPath });
+      } catch (error) {
+        return c.json(
+          {
+            error: "Failed to read config file",
+            message: error instanceof Error ? error.message : "Unknown error",
+          },
+          500
+        );
+      }
+    });
+
     // Serve UI
     app.get("/", (c) => c.html(generateBrowserUI(graphData)));
 
@@ -705,6 +729,89 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       color: var(--change-added);
     }
 
+    /* Source View */
+    .source-view {
+      display: none;
+      grid-column: 2 / 4;
+      padding: 24px;
+      overflow-y: auto;
+      background: linear-gradient(to bottom, rgba(255, 255, 255, 0.5), rgba(231, 225, 207, 0.3));
+    }
+
+    .source-view.active {
+      display: flex;
+      flex-direction: column;
+    }
+
+    .source-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 20px;
+      background: rgba(2, 61, 96, 0.95);
+      border-radius: 12px 12px 0 0;
+      color: white;
+    }
+
+    .source-filename {
+      font-family: 'Space Mono', monospace;
+      font-size: 13px;
+      font-weight: 500;
+    }
+
+    .copy-btn {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 6px 12px;
+      background: rgba(255, 255, 255, 0.1);
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      border-radius: 6px;
+      color: white;
+      font-family: 'Space Grotesk', sans-serif;
+      font-size: 12px;
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+
+    .copy-btn:hover {
+      background: rgba(255, 255, 255, 0.2);
+    }
+
+    .copy-btn.copied {
+      background: rgba(21, 168, 168, 0.3);
+      border-color: var(--vanna-teal);
+    }
+
+    .source-code {
+      flex: 1;
+      margin: 0;
+      padding: 20px;
+      background: #1e1e1e;
+      border-radius: 0 0 12px 12px;
+      overflow: auto;
+      font-family: 'Space Mono', monospace;
+      font-size: 13px;
+      line-height: 1.6;
+      color: #d4d4d4;
+      tab-size: 2;
+    }
+
+    .source-code code {
+      display: block;
+      white-space: pre;
+    }
+
+    /* Syntax highlighting classes */
+    .source-code .keyword { color: #569cd6; }
+    .source-code .string { color: #ce9178; }
+    .source-code .number { color: #b5cea8; }
+    .source-code .comment { color: #6a9955; }
+    .source-code .function { color: #dcdcaa; }
+    .source-code .type { color: #4ec9b0; }
+    .source-code .property { color: #9cdcfe; }
+    .source-code .punctuation { color: #d4d4d4; }
+
     /* No Changes State */
     .no-changes {
       text-align: center;
@@ -1433,6 +1540,7 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       <div class="view-tabs">
         <button class="view-tab active" data-view="graph">Graph</button>
         <button class="view-tab" data-view="table">Table</button>
+        <button class="view-tab" data-view="source">Source</button>
       </div>
 
       <div class="filter-buttons" id="graphFilters">
@@ -1553,6 +1661,20 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
     <div class="table-view" id="tableView">
       <div id="tableContent"></div>
     </div>
+
+    <!-- Source View -->
+    <div class="source-view" id="sourceView">
+      <div class="source-header">
+        <span class="source-filename" id="sourceFilename">ontology.config.ts</span>
+        <button class="copy-btn" id="copySourceBtn" title="Copy to clipboard">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+          </svg>
+          Copy
+        </button>
+      </div>
+      <pre class="source-code" id="sourceCode"><code>Loading...</code></pre>
+    </div>
   </div>
 
   <!-- Review Footer -->
@@ -2429,6 +2551,7 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       const graphContainer = document.querySelector('.graph-container');
       const detailPanel = document.getElementById('detailPanel');
       const tableView = document.getElementById('tableView');
+      const sourceView = document.getElementById('sourceView');
       const graphFilters = document.getElementById('graphFilters');
       const layoutSelector = document.querySelector('.layout-selector');
 
@@ -2436,15 +2559,25 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
         graphContainer.style.display = 'block';
         detailPanel.style.display = 'block';
         tableView.classList.remove('active');
+        sourceView.classList.remove('active');
         if (graphFilters) graphFilters.style.display = 'flex';
         if (layoutSelector) layoutSelector.style.display = 'flex';
-      } else {
+      } else if (view === 'table') {
         graphContainer.style.display = 'none';
         detailPanel.style.display = 'none';
         tableView.classList.add('active');
+        sourceView.classList.remove('active');
         if (graphFilters) graphFilters.style.display = 'none';
         if (layoutSelector) layoutSelector.style.display = 'none';
         renderTableView();
+      } else if (view === 'source') {
+        graphContainer.style.display = 'none';
+        detailPanel.style.display = 'none';
+        tableView.classList.remove('active');
+        sourceView.classList.add('active');
+        if (graphFilters) graphFilters.style.display = 'none';
+        if (layoutSelector) layoutSelector.style.display = 'none';
+        loadSourceView();
       }
     }
 
@@ -2486,6 +2619,74 @@ function generateBrowserUI(graphData: EnhancedGraphData): string {
       });
     }
 
+    // Source view
+    let sourceLoaded = false;
+    let sourceContent = '';
+
+    async function loadSourceView() {
+      if (sourceLoaded) return;
+
+      const codeEl = document.getElementById('sourceCode').querySelector('code');
+      const filenameEl = document.getElementById('sourceFilename');
+
+      try {
+        const res = await fetch('/api/source');
+        if (!res.ok) throw new Error('Failed to load source');
+        const data = await res.json();
+
+        sourceContent = data.source;
+        filenameEl.textContent = data.filename;
+        codeEl.innerHTML = highlightTypeScript(data.source);
+        sourceLoaded = true;
+      } catch (err) {
+        codeEl.textContent = 'Error loading source: ' + err.message;
+      }
+    }
+
+    function highlightTypeScript(code) {
+      // Escape HTML first
+      code = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+      // Comments (single and multi-line)
+      code = code.replace(/(\\/\\/.*$)/gm, '<span class="comment">$1</span>');
+      code = code.replace(/(\\/\\*[\\s\\S]*?\\*\\/)/g, '<span class="comment">$1</span>');
+
+      // Strings (double, single, and template)
+      code = code.replace(/("(?:[^"\\\\]|\\\\.)*")/g, '<span class="string">$1</span>');
+      code = code.replace(/('(?:[^'\\\\]|\\\\.)*')/g, '<span class="string">$1</span>');
+      code = code.replace(/(\`(?:[^\`\\\\]|\\\\.)*\`)/g, '<span class="string">$1</span>');
+
+      // Keywords
+      const keywords = ['import', 'export', 'from', 'const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'extends', 'new', 'this', 'true', 'false', 'null', 'undefined', 'typeof', 'instanceof', 'async', 'await', 'default', 'as', 'type', 'interface'];
+      keywords.forEach(kw => {
+        code = code.replace(new RegExp('\\\\b(' + kw + ')\\\\b', 'g'), '<span class="keyword">$1</span>');
+      });
+
+      // Numbers
+      code = code.replace(/\\b(\\d+\\.?\\d*)\\b/g, '<span class="number">$1</span>');
+
+      // Function calls
+      code = code.replace(/\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(/g, '<span class="function">$1</span>(');
+
+      return code;
+    }
+
+    // Copy source button
+    document.getElementById('copySourceBtn').addEventListener('click', async () => {
+      const btn = document.getElementById('copySourceBtn');
+      try {
+        await navigator.clipboard.writeText(sourceContent);
+        btn.classList.add('copied');
+        btn.innerHTML = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="20 6 9 17 4 12"/></svg> Copied!';
+        setTimeout(() => {
+          btn.classList.remove('copied');
+          btn.innerHTML = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg> Copy';
+        }, 2000);
+      } catch (err) {
+        console.error('Failed to copy:', err);
+      }
+    });
+
     function renderTableSection(title, items, type) {
       const changedCount = items.filter(n => n.changeStatus !== 'unchanged').length;
 

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";
@@ -16,7 +25,6 @@ export interface GraphNode {
   metadata: {
     inputs?: Record<string, unknown>;
     outputs?: Record<string, unknown>;
-    resolver?: string;
     functionCount?: number;
     usesUserContext?: boolean;
   };
@@ -81,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;
@@ -115,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 {
@@ -173,7 +195,6 @@ export function transformToGraphData(config: OntologyConfig): GraphData {
       metadata: {
         inputs: safeZodToJsonSchema(fn.inputs),
         outputs: fn.outputs ? safeZodToJsonSchema(fn.outputs) : undefined,
-        resolver: fn.resolver,
         usesUserContext: usesUserContext || undefined,
       },
     });

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/cli/commands/review.ts

@@ -48,7 +48,7 @@ export const reviewCommand = defineCommand({
 
       // Load config
       consola.info("Loading ontology config...");
-      const { config, configDir } = await loadConfig();
+      const { config, configDir, configPath } = await loadConfig();
 
       // Compute current ontology snapshot
       const { ontology: newOntology, hash: newHash } = computeOntologyHash(config);
@@ -107,6 +107,7 @@ export const reviewCommand = defineCommand({
         config,
         diff: diff.hasChanges ? diff : null,
         configDir,
+        configPath,
       });
 
       if (diff.hasChanges) {

package/src/config/define.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import {
   OntologyConfigSchema,
   validateAccessGroups,
@@ -11,6 +12,7 @@ import type {
   EnvironmentConfig,
   EntityDefinition,
   AuthFunction,
+  ResolverFunction,
 } from "./types.js";
 
 /**
@@ -20,6 +22,7 @@ import type {
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { getUser } from './resolvers/getUser.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -44,7 +47,7 @@ import type {
  *       access: ['public', 'admin'],
  *       entities: ['User'],
  *       inputs: z.object({ id: z.string() }),
- *       resolver: './resolvers/getUser.ts',
+ *       resolver: getUser,  // Direct function reference for type safety
  *     },
  *   },
  * });
@@ -53,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>;
@@ -76,3 +81,48 @@ export function defineOntology<
 
   return config as OntologyConfig<TGroups, TEntities, TFunctions>;
 }
+
+/**
+ * Define a function with full type inference for resolver type safety.
+ *
+ * This helper ensures that the resolver function's return type matches
+ * the outputs Zod schema at compile time.
+ *
+ * @example
+ * ```ts
+ * import { defineFunction, z } from 'ont-run';
+ * import type { ResolverContext } from 'ont-run';
+ *
+ * const getUser = defineFunction({
+ *   description: 'Get a user by ID',
+ *   access: ['public', 'admin'] as const,
+ *   entities: ['User'] as const,
+ *   inputs: z.object({ id: z.string() }),
+ *   outputs: z.object({ id: z.string(), name: z.string() }),
+ *   resolver: async (ctx, args) => {
+ *     // TypeScript knows args is { id: string }
+ *     // TypeScript enforces return type is { id: string, name: string }
+ *     return { id: args.id, name: 'Example User' };
+ *   },
+ * });
+ * ```
+ */
+export function defineFunction<
+  TGroups extends string,
+  TEntities extends string,
+  TInputs extends z.ZodType,
+  TOutputs extends z.ZodType,
+>(config: {
+  description: string;
+  access: readonly TGroups[];
+  entities: readonly TEntities[];
+  inputs: TInputs;
+  outputs?: TOutputs;
+  resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
+}): FunctionDefinition<TGroups, TEntities, TInputs, TOutputs> {
+  return {
+    ...config,
+    access: [...config.access],
+    entities: [...config.entities],
+  };
+}

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.string(),
+  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;