ont-run 0.0.4 → 0.0.6

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,13 +32,13 @@ 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
  *     },
  *   },
  * });
  * ```
  */
-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;
@@ -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

@@ -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.ZodString;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    access: string[];
-    entities: string[];
-    inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: string;
-    outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-}, {
-    description: string;
-    access: string[];
-    entities: string[];
-    inputs: z.ZodType<any, z.ZodTypeDef, any>;
-    resolver: string;
-    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.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
-        outputs?: z.ZodType<any, z.ZodTypeDef, any> | undefined;
-    }, {
-        description: string;
-        access: string[];
-        entities: string[];
-        inputs: z.ZodType<any, z.ZodTypeDef, any>;
-        resolver: string;
-        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: string;
-        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: string;
-        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/types.d.ts

@@ -32,10 +32,32 @@ export interface FieldOption {
     /** Human-readable label for display */
     label: string;
 }
+/**
+ * Context passed to resolvers
+ */
+export interface ResolverContext {
+    /** Current environment name */
+    env: string;
+    /** Environment configuration */
+    envConfig: EnvironmentConfig;
+    /** Logger instance */
+    logger: {
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+        debug: (message: string, ...args: unknown[]) => void;
+    };
+    /** Access groups for the current request */
+    accessGroups: string[];
+}
+/**
+ * Resolver function signature
+ */
+export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;
 /**
  * Definition of a function in the ontology
  */
-export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string> {
+export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string, TInputs extends z.ZodType = z.ZodType<unknown>, TOutputs extends z.ZodType = z.ZodType<unknown>> {
     /** Human-readable description of what this function does */
     description: string;
     /** Which access groups can call this function */
@@ -43,11 +65,11 @@ export interface FunctionDefinition<TGroups extends string = string, TEntities e
     /** Which entities this function relates to (use empty array [] if none) */
     entities: TEntities[];
     /** Zod schema for input validation */
-    inputs: z.ZodType<unknown>;
+    inputs: TInputs;
     /** Zod schema for output validation/documentation */
-    outputs?: z.ZodType<unknown>;
-    /** Path to the resolver file (relative to ontology.config.ts) */
-    resolver: string;
+    outputs?: TOutputs;
+    /** Resolver function that handles this function's logic */
+    resolver: ResolverFunction<z.infer<TInputs>, z.infer<TOutputs>>;
 }
 /**
  * Result returned by the auth function
@@ -82,25 +104,3 @@ export interface OntologyConfig<TGroups extends string = string, TEntities exten
     /** Function definitions */
     functions: TFunctions;
 }
-/**
- * Context passed to resolvers
- */
-export interface ResolverContext {
-    /** Current environment name */
-    env: string;
-    /** Environment configuration */
-    envConfig: EnvironmentConfig;
-    /** Logger instance */
-    logger: {
-        info: (message: string, ...args: unknown[]) => void;
-        warn: (message: string, ...args: unknown[]) => void;
-        error: (message: string, ...args: unknown[]) => void;
-        debug: (message: string, ...args: unknown[]) => void;
-    };
-    /** Access groups for the current request */
-    accessGroups: string[];
-}
-/**
- * Resolver function signature
- */
-export type ResolverFunction<TArgs = unknown, TResult = unknown> = (ctx: ResolverContext, args: TArgs) => Promise<TResult> | TResult;

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/dist/src/index.d.ts

@@ -5,6 +5,7 @@
  * ```ts
  * import { defineOntology, fieldFrom } from 'ont-run';
  * import { z } from 'zod';
+ * import { hello } from './resolvers/hello.js';
  *
  * export default defineOntology({
  *   name: 'my-api',
@@ -23,13 +24,13 @@
  *       access: ['public'],
  *       entities: [],
  *       inputs: z.object({ name: z.string() }),
- *       resolver: './resolvers/hello.ts',
+ *       resolver: hello,  // Direct function reference for type safety
  *     },
  *   },
  * });
  * ```
  */
-export { defineOntology } from "./config/define.js";
+export { defineOntology, defineFunction } from "./config/define.js";
 export { fieldFrom, userContext } from "./config/categorical.js";
 export { startOnt } from "./server/start.js";
 export type { StartOntOptions, StartOntResult } from "./server/start.js";

package/dist/src/server/api/index.d.ts

@@ -4,8 +4,6 @@ import { type OntologyVariables } from "./middleware.js";
 export interface ApiServerOptions {
     /** The ontology configuration */
     config: OntologyConfig;
-    /** Directory containing the ontology.config.ts (for resolving resolver paths) */
-    configDir: string;
     /** Environment to use (e.g., 'dev', 'prod') */
     env: string;
     /** Enable CORS (default: true) */

package/dist/src/server/api/router.d.ts

@@ -4,7 +4,7 @@ import { type OntologyVariables } from "./middleware.js";
 /**
  * Create API routes from function definitions
  */
-export declare function createApiRoutes(config: OntologyConfig, configDir: string): Hono<{
+export declare function createApiRoutes(config: OntologyConfig): Hono<{
     Variables: OntologyVariables;
 }>;
 /**

package/dist/src/server/mcp/index.d.ts

@@ -3,8 +3,6 @@ import type { OntologyConfig } from "../../config/types.js";
 export interface McpServerOptions {
     /** The ontology configuration */
     config: OntologyConfig;
-    /** Directory containing the ontology.config.ts */
-    configDir: string;
     /** Environment to use */
     env: string;
     /** Port for the MCP HTTP server */

package/dist/src/server/mcp/tools.d.ts

@@ -1,5 +1,5 @@
 import type { OntologyConfig, EnvironmentConfig, AuthResult } from "../../config/types.js";
-import { type Logger } from "../resolver.js";
+import type { Logger } from "../resolver.js";
 /**
  * Field reference info for MCP tools
  */
@@ -32,4 +32,4 @@ export declare function filterToolsByAccess(tools: McpTool[], accessGroups: stri
 /**
  * Create a tool executor function that accepts per-request auth result
  */
-export declare function createToolExecutor(config: OntologyConfig, configDir: string, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;
+export declare function createToolExecutor(config: OntologyConfig, env: string, envConfig: EnvironmentConfig, logger: Logger): (toolName: string, args: unknown, authResult: AuthResult) => Promise<unknown>;

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

@@ -1,20 +1,9 @@
-import type { ResolverFunction, OntologyConfig } from "../config/types.js";
+import type { ResolverFunction } from "../config/types.js";
 /**
- * Load a resolver from a file path.
- * The path is relative to the config file location.
- *
- * @param resolverPath - Path to the resolver file (relative to configDir)
- * @param configDir - Directory containing the ontology.config.ts
+ * Get a resolver function. Since resolvers are now passed directly as functions,
+ * this is a simple passthrough that could be removed in the future.
  */
-export declare function loadResolver(resolverPath: string, configDir: string): Promise<ResolverFunction>;
-/**
- * Clear the resolver cache (useful for hot reloading)
- */
-export declare function clearResolverCache(): void;
-/**
- * Check which resolvers are missing and return their paths
- */
-export declare function findMissingResolvers(config: OntologyConfig, configDir: string): string[];
+export declare function loadResolver(resolver: ResolverFunction): ResolverFunction;
 /**
  * Logger type returned by createLogger
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.4",
+  "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",