ont-run 0.0.4 → 0.0.5

package/README.md

@@ -7,6 +7,8 @@ A web framework designed for the era of coding agents. You define the ontology
 ```typescript
 // ontology.config.ts
 import { defineOntology, z } from 'ont-run';
+import getTicket from './resolvers/getTicket.js';
+import assignTicket from './resolvers/assignTicket.js';
 
 export default defineOntology({
   name: 'support-desk',
@@ -23,14 +25,14 @@ export default defineOntology({
       access: ['support', 'admin'],
       entities: ['Ticket'],
       inputs: z.object({ ticketId: z.string().uuid() }),
-      resolver: './resolvers/getTicket.ts',
+      resolver: getTicket,
     },
     assignTicket: {
       description: 'Assign ticket to an agent',
       access: ['admin'],  // If AI tries to add 'public' here, review is triggered
       entities: ['Ticket'],
       inputs: z.object({ ticketId: z.string().uuid(), assignee: z.string() }),
-      resolver: './resolvers/assignTicket.ts',
+      resolver: assignTicket,
     },
   },
   // ...
@@ -141,6 +143,7 @@ The resolver context provides:
 
 ```typescript
 import { defineOntology, z } from 'ont-run';
+import getUser from './resolvers/getUser.js';
 
 export default defineOntology({
   name: 'my-api',
@@ -179,7 +182,7 @@ export default defineOntology({
       access: ['user', 'admin'],
       entities: ['User'],
       inputs: z.object({ userId: z.string().uuid() }),
-      resolver: './resolvers/getUser.ts',
+      resolver: getUser,
     },
   },
 });
@@ -191,6 +194,7 @@ The framework handles **group-based access** (user → group → function) out o
 
 ```typescript
 import { defineOntology, userContext, z } from 'ont-run';
+import editPost from './resolvers/editPost.js';
 
 export default defineOntology({
   // Auth must return user identity for userContext to work
@@ -216,7 +220,7 @@ export default defineOntology({
           email: z.string(),
         })),
       }),
-      resolver: './resolvers/editPost.ts',
+      resolver: editPost,
     },
   },
 });

package/dist/bin/ont.js

@@ -10233,6 +10233,10 @@ var Hono2 = class extends Hono {
   }
 };
 
+// src/browser/server.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+
 // node_modules/open/index.js
 import process7 from "node:process";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -10869,7 +10873,6 @@ function transformToGraphData(config) {
       metadata: {
         inputs: safeZodToJsonSchema(fn.inputs),
         outputs: fn.outputs ? safeZodToJsonSchema(fn.outputs) : undefined,
-        resolver: fn.resolver,
         usesUserContext: usesUserContext || undefined
       }
     });
@@ -11103,7 +11106,7 @@ function enhanceWithDiff(graphData, diff) {
 
 // src/browser/server.ts
 async function startBrowserServer(options) {
-  const { config, diff = null, configDir, port: preferredPort, openBrowser = true } = options;
+  const { config, diff = null, configDir, configPath, port: preferredPort, openBrowser = true } = options;
   const baseGraphData = transformToGraphData(config);
   const graphData = enhanceWithDiff(baseGraphData, diff);
   return new Promise(async (resolve2) => {
@@ -11150,6 +11153,21 @@ async function startBrowserServer(options) {
       }, 500);
       return c3.json({ success: true });
     });
+    app.get("/api/source", (c3) => {
+      if (!configPath) {
+        return c3.json({ error: "Config path not available" }, 400);
+      }
+      try {
+        const source = readFileSync2(configPath, "utf-8");
+        const filename = basename(configPath);
+        return c3.json({ source, filename, path: configPath });
+      } catch (error) {
+        return c3.json({
+          error: "Failed to read config file",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }, 500);
+      }
+    });
     app.get("/", (c3) => c3.html(generateBrowserUI(graphData)));
     const port = preferredPort || await findAvailablePort(3457);
     const server = await serve2(app, port);
@@ -11758,6 +11776,89 @@ function generateBrowserUI(graphData) {
       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;
@@ -12486,6 +12587,7 @@ function generateBrowserUI(graphData) {
       <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">
@@ -12606,6 +12708,20 @@ function generateBrowserUI(graphData) {
     <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 -->
@@ -13482,6 +13598,7 @@ function generateBrowserUI(graphData) {
       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');
 
@@ -13489,15 +13606,25 @@ function generateBrowserUI(graphData) {
         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();
       }
     }
 
@@ -13539,6 +13666,74 @@ function generateBrowserUI(graphData) {
       });
     }
 
+    // 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;
 
@@ -13712,7 +13907,7 @@ var reviewCommand = defineCommand({
         process.exit(0);
       }
       consola.info("Loading ontology config...");
-      const { config, configDir } = await loadConfig();
+      const { config, configDir, configPath } = await loadConfig();
       const { ontology: newOntology, hash: newHash } = computeOntologyHash(config);
       const lockfile = await readLockfile(configDir);
       const oldOntology = lockfile?.ontology || null;
@@ -13760,7 +13955,8 @@ var reviewCommand = defineCommand({
       const result = await startBrowserServer({
         config,
         diff: diff.hasChanges ? diff : null,
-        configDir
+        configDir,
+        configPath
       });
       if (diff.hasChanges) {
         if (result.approved) {
@@ -13780,7 +13976,7 @@ var reviewCommand = defineCommand({
 // package.json
 var package_default = {
   name: "ont-run",
-  version: "0.0.4",
+  version: "0.0.5",
   description: "Ontology-enforced API framework for AI coding agents",
   type: "module",
   bin: {

package/dist/index.js

@@ -13489,7 +13489,7 @@ var FunctionDefinitionSchema = exports_external.object({
   outputs: exports_external.custom(isZodSchema, {
     message: "outputs must be a Zod schema"
   }).optional(),
-  resolver: exports_external.string()
+  resolver: exports_external.function()
 });
 var AuthFunctionSchema = exports_external.function().args(exports_external.custom()).returns(exports_external.union([exports_external.array(exports_external.string()), exports_external.promise(exports_external.array(exports_external.string()))]));
 var OntologyConfigSchema = exports_external.object({
@@ -13606,6 +13606,13 @@ function defineOntology(config) {
   validateFieldFromReferences(parsed);
   return config;
 }
+function defineFunction(config) {
+  return {
+    ...config,
+    access: [...config.access],
+    entities: [...config.entities]
+  };
+}
 
 // src/index.ts
 init_categorical();
@@ -16301,39 +16308,6 @@ var Factory = class {
 var createMiddleware = (middleware) => middleware;
 
 // src/server/resolver.ts
-import { join as join3, isAbsolute } from "path";
-import { existsSync as existsSync3 } from "fs";
-var resolverCache = new Map;
-async function loadResolver(resolverPath, configDir) {
-  const fullPath = isAbsolute(resolverPath) ? resolverPath : join3(configDir, resolverPath);
-  if (resolverCache.has(fullPath)) {
-    return resolverCache.get(fullPath);
-  }
-  try {
-    const module = await import(fullPath);
-    const resolver = module.default;
-    if (typeof resolver !== "function") {
-      throw new Error(`Resolver at ${resolverPath} must export a default function`);
-    }
-    resolverCache.set(fullPath, resolver);
-    return resolver;
-  } catch (error) {
-    if (error.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(`Resolver not found: ${resolverPath}`);
-    }
-    throw error;
-  }
-}
-function findMissingResolvers(config, configDir) {
-  const missing = [];
-  for (const [name, fn] of Object.entries(config.functions)) {
-    const fullPath = isAbsolute(fn.resolver) ? fn.resolver : join3(configDir, fn.resolver);
-    if (!existsSync3(fullPath)) {
-      missing.push(fn.resolver);
-    }
-  }
-  return missing;
-}
 function createLogger(debug = false) {
   return {
     info: (message, ...args) => {
@@ -16422,7 +16396,7 @@ function errorHandler2() {
 
 // src/server/api/router.ts
 init_categorical();
-function createApiRoutes(config, configDir) {
+function createApiRoutes(config) {
   const router = new Hono2;
   for (const [name, fn] of Object.entries(config.functions)) {
     const path = `/${name}`;
@@ -16465,8 +16439,7 @@ function createApiRoutes(config, configDir) {
         args = parsed.data;
       }
       try {
-        const resolver = await loadResolver(fn.resolver, configDir);
-        const result = await resolver(resolverContext, args);
+        const result = await fn.resolver(resolverContext, args);
         return c3.json(result);
       } catch (error) {
         console.error(`Error in resolver ${name}:`, error);
@@ -16490,18 +16463,11 @@ function getFunctionsInfo(config) {
 
 // src/server/api/index.ts
 function createApiApp(options) {
-  const { config, configDir, env: env2, cors: enableCors = true } = options;
+  const { config, env: env2, cors: enableCors = true } = options;
   const envConfig = config.environments[env2];
   if (!envConfig) {
     throw new Error(`Unknown environment "${env2}". Available: ${Object.keys(config.environments).join(", ")}`);
   }
-  const missingResolvers = findMissingResolvers(config, configDir);
-  if (missingResolvers.length > 0) {
-    consola.warn(`Missing resolvers (${missingResolvers.length}):`);
-    for (const resolver of missingResolvers) {
-      consola.warn(`  - ${resolver}`);
-    }
-  }
   const app = new Hono2;
   if (enableCors) {
     app.use("*", cors());
@@ -16527,7 +16493,7 @@ function createApiApp(options) {
       functions: accessibleFunctions
     });
   });
-  const apiRoutes = createApiRoutes(config, configDir);
+  const apiRoutes = createApiRoutes(config);
   app.route("/api", apiRoutes);
   return app;
 }
@@ -23017,7 +22983,7 @@ function generateMcpTools(config2) {
 function filterToolsByAccess(tools, accessGroups) {
   return tools.filter((tool) => tool.access.some((group) => accessGroups.includes(group)));
 }
-function createToolExecutor(config2, configDir, env2, envConfig, logger) {
+function createToolExecutor(config2, env2, envConfig, logger) {
   const userContextFieldsCache = new Map;
   for (const [name, fn] of Object.entries(config2.functions)) {
     userContextFieldsCache.set(name, getUserContextFields(fn.inputs));
@@ -23049,8 +23015,7 @@ function createToolExecutor(config2, configDir, env2, envConfig, logger) {
       logger,
       accessGroups: authResult.groups
     };
-    const resolver = await loadResolver(fn.resolver, configDir);
-    return resolver(resolverContext, parsed.data);
+    return fn.resolver(resolverContext, parsed.data);
   };
 }
 
@@ -23103,14 +23068,14 @@ function getAuthResult(authInfo) {
   return authInfo.extra.authResult;
 }
 function createMcpServer(options) {
-  const { config: config2, configDir, env: env2 } = options;
+  const { config: config2, env: env2 } = options;
   const envConfig = config2.environments[env2];
   if (!envConfig) {
     throw new Error(`Unknown environment "${env2}". Available: ${Object.keys(config2.environments).join(", ")}`);
   }
   const logger = createLogger(envConfig.debug);
   const allTools = generateMcpTools(config2);
-  const executeToolWithAccess = createToolExecutor(config2, configDir, env2, envConfig, logger);
+  const executeToolWithAccess = createToolExecutor(config2, env2, envConfig, logger);
   const server = new Server({
     name: config2.name,
     version: "1.0.0"
@@ -23267,7 +23232,6 @@ Run \`bun run review\` to approve the changes.`;
   if (!mcpOnly) {
     const api2 = createApiApp({
       config: config2,
-      configDir,
       env: env2
     });
     const server = await serve2(api2, port);
@@ -23286,7 +23250,6 @@ Run \`bun run review\` to approve the changes.`;
   if (!apiOnly) {
     const mcpServer = await startMcpServer({
       config: config2,
-      configDir,
       env: env2,
       port: mcpPort
     });
@@ -23305,5 +23268,6 @@ export {
   userContext,
   startOnt,
   fieldFrom,
-  defineOntology
+  defineOntology,
+  defineFunction
 };

package/dist/src/browser/server.d.ts

@@ -6,6 +6,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;
 }

package/dist/src/browser/transform.d.ts

@@ -11,7 +11,6 @@ export interface GraphNode {
     metadata: {
         inputs?: Record<string, unknown>;
         outputs?: Record<string, unknown>;
-        resolver?: string;
         functionCount?: number;
         usesUserContext?: boolean;
     };

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

@@ -1,4 +1,5 @@
-import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction } from "./types.js";
+import { z } from "zod";
+import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction, ResolverFunction } from "./types.js";
 /**
  * Define an Ontology configuration with full type inference.
  *
@@ -6,6 +7,7 @@ import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, Environment
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { getUser } from './resolvers/getUser.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -30,7 +32,7 @@ import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, Environment
  *       access: ['public', 'admin'],
  *       entities: ['User'],
  *       inputs: z.object({ id: z.string() }),
- *       resolver: './resolvers/getUser.ts',
+ *       resolver: getUser,  // Direct function reference for type safety
  *     },
  *   },
  * });
@@ -44,3 +46,36 @@ export declare function defineOntology<TGroups extends string, TEntities extends
     entities?: Record<TEntities, EntityDefinition>;
     functions: TFunctions;
 }): 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 declare 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>;

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

@@ -39,20 +39,20 @@ export declare const FunctionDefinitionSchema: z.ZodObject<{
     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.ZodString;
+    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: string;
+    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: string;
+    resolver: (...args: unknown[]) => unknown;
     outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
 }>;
 /**
@@ -92,20 +92,20 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         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.ZodString;
+        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: string;
+        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: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
@@ -122,7 +122,7 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>;
     entities?: Record<string, {
@@ -142,7 +142,7 @@ export declare const OntologyConfigSchema: z.ZodObject<{
         access: string[];
         entities: string[];
         inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
+        resolver: (...args: unknown[]) => unknown;
         outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
     }>;
     entities?: Record<string, {