ont-run 0.0.1

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

@@ -0,0 +1,16 @@
+import type { OntologyConfig } from "../config/types.js";
+import type { OntologyDiff } from "../lockfile/types.js";
+export interface BrowserServerOptions {
+    config: OntologyConfig;
+    /** Diff data for review mode (null = browse-only, no changes) */
+    diff?: OntologyDiff | null;
+    /** Directory to write the lockfile to on approval */
+    configDir?: string;
+    port?: number;
+    openBrowser?: boolean;
+}
+export interface BrowserServerResult {
+    /** Whether changes were approved (only set if there were changes) */
+    approved?: boolean;
+}
+export declare function startBrowserServer(options: BrowserServerOptions): Promise<BrowserServerResult>;

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

@@ -0,0 +1,87 @@
+import type { OntologyConfig } from "../config/types.js";
+import type { OntologyDiff, FunctionChange } from "../lockfile/types.js";
+export type NodeType = "entity" | "function" | "accessGroup";
+export type EdgeType = "operates-on" | "requires-access" | "depends-on";
+export type ChangeStatus = "added" | "removed" | "modified" | "unchanged";
+export interface GraphNode {
+    id: string;
+    type: NodeType;
+    label: string;
+    description: string;
+    metadata: {
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+        resolver?: string;
+        functionCount?: number;
+    };
+}
+export interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: EdgeType;
+    label?: string;
+}
+export interface GraphData {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    meta: {
+        ontologyName: string;
+        totalFunctions: number;
+        totalEntities: number;
+        totalAccessGroups: number;
+    };
+}
+export interface EnhancedGraphNode extends GraphNode {
+    changeStatus: ChangeStatus;
+    changeDetails?: FunctionChange;
+}
+export interface EnhancedGraphData {
+    nodes: EnhancedGraphNode[];
+    edges: GraphEdge[];
+    meta: GraphData["meta"] & {
+        hasChanges: boolean;
+        addedCount: number;
+        removedCount: number;
+        modifiedCount: number;
+    };
+    diff: OntologyDiff | null;
+}
+/**
+ * Transform OntologyConfig into graph data for visualization
+ */
+export declare function transformToGraphData(config: OntologyConfig): GraphData;
+/**
+ * Search nodes by label or description
+ */
+export declare function searchNodes(graphData: GraphData, query: string): Array<{
+    id: string;
+    type: NodeType;
+    label: string;
+    matchType: "label" | "description";
+}>;
+/**
+ * Get detailed node information including connections
+ */
+export declare function getNodeDetails(graphData: GraphData, nodeId: string): {
+    node: GraphNode | null;
+    connections: {
+        accessGroups: string[];
+        entities: string[];
+        dependsOn: Array<{
+            functionName: string;
+            path: string;
+        }>;
+        dependedOnBy: string[];
+        functions: Array<{
+            name: string;
+            description: string;
+            inputs?: Record<string, unknown>;
+            outputs?: Record<string, unknown>;
+        }>;
+    };
+};
+/**
+ * Enhance graph data with diff information for review mode
+ */
+export declare function enhanceWithDiff(graphData: GraphData, diff: OntologyDiff | null): EnhancedGraphData;

package/dist/src/cli/commands/init.d.ts

@@ -0,0 +1,12 @@
+export declare const initCommand: import("citty").CommandDef<{
+    dir: {
+        type: "positional";
+        description: string;
+        default: string;
+    };
+    force: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;

package/dist/src/cli/commands/review.d.ts

@@ -0,0 +1,17 @@
+export declare const reviewCommand: import("citty").CommandDef<{
+    "auto-approve": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "print-only": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    cloud: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;

package/dist/src/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function run(): void;

package/dist/src/cli/utils/config-loader.d.ts

@@ -0,0 +1,13 @@
+import type { OntologyConfig } from "../../config/types.js";
+/**
+ * Find the ontology config file in the given directory or its parents
+ */
+export declare function findConfigFile(startDir?: string): string | null;
+/**
+ * Load the ontology config from a file
+ */
+export declare function loadConfig(configPath?: string): Promise<{
+    config: OntologyConfig;
+    configDir: string;
+    configPath: string;
+}>;

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/**
+ * Symbol for storing fieldFrom metadata on Zod schemas
+ */
+export declare const FIELD_FROM_METADATA: unique symbol;
+/**
+ * Metadata stored on fieldFrom Zod schemas
+ */
+export interface FieldFromMetadata {
+    /** Name of the function that provides options for this field */
+    functionName: string;
+}
+/**
+ * Type for a Zod string with fieldFrom metadata
+ */
+export type FieldFromString = z.ZodString & {
+    [FIELD_FROM_METADATA]: FieldFromMetadata;
+};
+/**
+ * Create a string field that gets its options from another function.
+ *
+ * The referenced function should return `{ value: string, label: string }[]`.
+ * - If the function has empty inputs `z.object({})`, it's treated as **bulk** (all options fetched at once)
+ * - If the function has a `query` input, it's treated as **autocomplete** (options searched)
+ *
+ * @param functionName - Name of the function that provides options
+ *
+ * @example
+ * ```ts
+ * defineOntology({
+ *   functions: {
+ *     // Bulk options source (empty inputs)
+ *     getUserStatuses: {
+ *       description: 'Get available user statuses',
+ *       access: ['admin'],
+ *       entities: [],
+ *       inputs: z.object({}),
+ *       outputs: z.array(z.object({ value: z.string(), label: z.string() })),
+ *       resolver: './resolvers/options/userStatuses.ts',
+ *     },
+ *
+ *     // Autocomplete source (has query input)
+ *     searchTeams: {
+ *       description: 'Search for teams',
+ *       access: ['admin'],
+ *       entities: [],
+ *       inputs: z.object({ query: z.string() }),
+ *       outputs: z.array(z.object({ value: z.string(), label: z.string() })),
+ *       resolver: './resolvers/options/searchTeams.ts',
+ *     },
+ *
+ *     // Function using fieldFrom
+ *     createUser: {
+ *       description: 'Create a user',
+ *       access: ['admin'],
+ *       entities: ['User'],
+ *       inputs: z.object({
+ *         name: z.string(),
+ *         status: fieldFrom('getUserStatuses'),
+ *         team: fieldFrom('searchTeams'),
+ *       }),
+ *       resolver: './resolvers/createUser.ts',
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare function fieldFrom(functionName: string): FieldFromString;
+/**
+ * Check if a Zod schema has fieldFrom metadata
+ */
+export declare function hasFieldFromMetadata(schema: unknown): schema is FieldFromString;
+/**
+ * Extract fieldFrom metadata from a Zod schema
+ */
+export declare function getFieldFromMetadata(schema: unknown): FieldFromMetadata | null;

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

@@ -0,0 +1,46 @@
+import type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction } from "./types.js";
+/**
+ * Define an Ontology configuration with full type inference.
+ *
+ * @example
+ * ```ts
+ * import { defineOntology, fieldFrom } from 'ont-run';
+ * import { z } from 'zod';
+ *
+ * export default defineOntology({
+ *   name: 'my-api',
+ *   environments: {
+ *     dev: { debug: true },
+ *     prod: { debug: false },
+ *   },
+ *   auth: async (req) => {
+ *     const token = req.headers.get('Authorization');
+ *     return token ? ['admin'] : ['public'];
+ *   },
+ *   accessGroups: {
+ *     public: { description: 'Unauthenticated users' },
+ *     admin: { description: 'Administrators' },
+ *   },
+ *   entities: {
+ *     User: { description: 'A user account' },
+ *   },
+ *   functions: {
+ *     getUser: {
+ *       description: 'Get a user by ID',
+ *       access: ['public', 'admin'],
+ *       entities: ['User'],
+ *       inputs: z.object({ id: z.string() }),
+ *       resolver: './resolvers/getUser.ts',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function defineOntology<TGroups extends string, TEntities extends string, TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities>>>(config: {
+    name: string;
+    environments: Record<string, EnvironmentConfig>;
+    auth: AuthFunction;
+    accessGroups: Record<TGroups, AccessGroupConfig>;
+    entities?: Record<TEntities, EntityDefinition>;
+    functions: TFunctions;
+}): OntologyConfig<TGroups, TEntities, TFunctions>;

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

@@ -0,0 +1,4 @@
+export { defineOntology } from "./define.js";
+export { fieldFrom } from "./categorical.js";
+export type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction, ResolverContext, ResolverFunction, FieldOption, } from "./types.js";
+export { OntologyConfigSchema, FunctionDefinitionSchema, AccessGroupConfigSchema, EnvironmentConfigSchema, EntityDefinitionSchema, validateAccessGroups, validateEntityReferences, validateFieldFromReferences, } from "./schema.js";

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

@@ -0,0 +1,162 @@
+import { z } from "zod";
+/**
+ * Schema for environment configuration
+ */
+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">>;
+/**
+ * Schema for access group configuration
+ */
+export declare const AccessGroupConfigSchema: z.ZodObject<{
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+}, {
+    description: string;
+}>;
+/**
+ * Schema for entity definition
+ */
+export declare const EntityDefinitionSchema: z.ZodObject<{
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+}, {
+    description: string;
+}>;
+/**
+ * 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">>]>>;
+/**
+ * Schema for the full ontology configuration
+ */
+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>;
+    accessGroups: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+    }, {
+        description: string;
+    }>>;
+    entities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+    }, {
+        description: string;
+    }>>>;
+    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;
+}>;
+/**
+ * Validate that all function access groups exist in accessGroups
+ */
+export declare function validateAccessGroups(config: z.infer<typeof OntologyConfigSchema>): void;
+/**
+ * Validate that all function entity references exist in entities
+ */
+export declare function validateEntityReferences(config: z.infer<typeof OntologyConfigSchema>): void;
+/**
+ * Validate that all fieldFrom() references point to existing functions
+ */
+export declare function validateFieldFromReferences(config: z.infer<typeof OntologyConfigSchema>): void;

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

@@ -0,0 +1,94 @@
+import type { z } from "zod";
+/**
+ * Configuration for an environment (dev, test, prod)
+ */
+export interface EnvironmentConfig {
+    /** Enable debug mode */
+    debug?: boolean;
+    /** Any additional environment-specific settings */
+    [key: string]: unknown;
+}
+/**
+ * Configuration for an access group
+ */
+export interface AccessGroupConfig {
+    /** Description of this access group */
+    description: string;
+}
+/**
+ * Definition of an entity in the ontology
+ */
+export interface EntityDefinition {
+    /** Human-readable description of this entity */
+    description: string;
+}
+/**
+ * Option returned by functions used as field sources.
+ * Functions referenced by `fieldFrom()` should return an array of these.
+ */
+export interface FieldOption {
+    /** The stored value */
+    value: string;
+    /** Human-readable label for display */
+    label: string;
+}
+/**
+ * Definition of a function in the ontology
+ */
+export interface FunctionDefinition<TGroups extends string = string, TEntities extends string = string> {
+    /** Human-readable description of what this function does */
+    description: string;
+    /** Which access groups can call this function */
+    access: TGroups[];
+    /** Which entities this function relates to (use empty array [] if none) */
+    entities: TEntities[];
+    /** Zod schema for input validation */
+    inputs: z.ZodType<unknown>;
+    /** Zod schema for output validation/documentation */
+    outputs?: z.ZodType<unknown>;
+    /** Path to the resolver file (relative to ontology.config.ts) */
+    resolver: string;
+}
+/**
+ * Auth function that determines access groups for a request
+ */
+export type AuthFunction = (req: Request) => Promise<string[]> | string[];
+/**
+ * The main Ontology configuration object
+ */
+export interface OntologyConfig<TGroups extends string = string, TEntities extends string = string, TFunctions extends Record<string, FunctionDefinition<TGroups, TEntities>> = Record<string, FunctionDefinition<TGroups, TEntities>>> {
+    /** Name of this ontology/API */
+    name: string;
+    /** Environment configurations */
+    environments: Record<string, EnvironmentConfig>;
+    /** Pluggable auth function */
+    auth: AuthFunction;
+    /** Access group definitions */
+    accessGroups: Record<TGroups, AccessGroupConfig>;
+    /** Entity definitions for categorization */
+    entities?: Record<TEntities, EntityDefinition>;
+    /** 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/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Ontology - Ontology-first backends with human-approved AI access & edits
+ *
+ * @example
+ * ```ts
+ * import { defineOntology, fieldFrom } from 'ont-run';
+ * import { z } from 'zod';
+ *
+ * export default defineOntology({
+ *   name: 'my-api',
+ *   environments: { dev: { debug: true }, prod: { debug: false } },
+ *   auth: async (req) => req.headers.get('Authorization') ? ['admin'] : ['public'],
+ *   accessGroups: {
+ *     public: { description: 'Unauthenticated' },
+ *     admin: { description: 'Administrators' },
+ *   },
+ *   entities: {
+ *     User: { description: 'A user account' },
+ *   },
+ *   functions: {
+ *     hello: {
+ *       description: 'Say hello',
+ *       access: ['public'],
+ *       entities: [],
+ *       inputs: z.object({ name: z.string() }),
+ *       resolver: './resolvers/hello.ts',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export { defineOntology } from "./config/define.js";
+export { fieldFrom } from "./config/categorical.js";
+export { startOnt } from "./server/start.js";
+export type { StartOntOptions, StartOntResult } from "./server/start.js";
+export type { OntologyConfig, FunctionDefinition, AccessGroupConfig, EnvironmentConfig, EntityDefinition, AuthFunction, ResolverContext, ResolverFunction, FieldOption, } from "./config/types.js";
+export { z } from "zod";

package/dist/src/lockfile/differ.d.ts

@@ -0,0 +1,11 @@
+import type { OntologySnapshot, OntologyDiff } from "./types.js";
+/**
+ * Compare two ontology snapshots and generate a diff.
+ * @param oldOntology - The previous ontology (from lockfile), or null if first run
+ * @param newOntology - The current ontology (from config)
+ */
+export declare function diffOntology(oldOntology: OntologySnapshot | null, newOntology: OntologySnapshot): OntologyDiff;
+/**
+ * Format a diff for console output
+ */
+export declare function formatDiffForConsole(diff: OntologyDiff): string;

package/dist/src/lockfile/hasher.d.ts

@@ -0,0 +1,31 @@
+import type { OntologyConfig } from "../config/types.js";
+import type { OntologySnapshot } from "./types.js";
+/**
+ * Extract the ontology snapshot from an OntologyConfig.
+ * This extracts ONLY the security-relevant parts:
+ * - Function names
+ * - Access lists
+ * - Input schemas
+ * - Output schemas
+ * - Descriptions
+ * - Entities
+ * - Field references (fieldFrom)
+ *
+ * It DOES NOT include:
+ * - Resolver paths (so resolver code can change freely)
+ * - Environment configs
+ * - Auth function
+ */
+export declare function extractOntology(config: OntologyConfig): OntologySnapshot;
+/**
+ * Create a deterministic hash of an ontology snapshot.
+ * Uses SHA256 and returns a 16-character hex string.
+ */
+export declare function hashOntology(ontology: OntologySnapshot): string;
+/**
+ * Extract ontology snapshot and compute hash in one step
+ */
+export declare function computeOntologyHash(config: OntologyConfig): {
+    ontology: OntologySnapshot;
+    hash: string;
+};

package/dist/src/lockfile/index.d.ts

@@ -0,0 +1,53 @@
+import type { Lockfile, OntologySnapshot } from "./types.js";
+export { extractOntology, hashOntology, computeOntologyHash } from "./hasher.js";
+export { diffOntology, formatDiffForConsole } from "./differ.js";
+export type { Lockfile, OntologySnapshot, OntologyDiff, FunctionChange, FunctionShape, } from "./types.js";
+/**
+ * Get the lockfile path for a given config directory
+ */
+export declare function getLockfilePath(configDir: string): string;
+/**
+ * Check if a lockfile exists
+ */
+export declare function lockfileExists(configDir: string): boolean;
+/**
+ * Read the lockfile from disk
+ * @returns The lockfile contents, or null if it doesn't exist
+ */
+export declare function readLockfile(configDir: string): Promise<Lockfile | null>;
+/**
+ * Write a lockfile to disk
+ */
+export declare function writeLockfile(configDir: string, ontology: OntologySnapshot, hash: string): Promise<void>;
+/**
+ * Check if the current ontology matches the lockfile
+ * @returns { match: true } if hashes match, or { match: false, lockfile, currentHash } if not
+ */
+export declare function checkLockfile(configDir: string, currentHash: string): Promise<{
+    match: true;
+    lockfile: Lockfile;
+} | {
+    match: false;
+    lockfile: Lockfile | null;
+    currentHash: string;
+}>;
+/**
+ * Result of lockfile validation
+ */
+export interface LockfileValidationResult {
+    /** Status of the lockfile check */
+    status: "valid" | "missing" | "mismatch";
+    /** The diff if there are changes (only present for 'mismatch' status) */
+    diff?: import("./types.js").OntologyDiff;
+    /** Human-readable message */
+    message: string;
+}
+/**
+ * Validate the lockfile against the current ontology.
+ * This is the main entry point for library use.
+ *
+ * @param configDir - Directory containing the ontology.config.ts
+ * @param currentOntology - The current ontology snapshot
+ * @param currentHash - The current ontology hash
+ */
+export declare function validateLockfile(configDir: string, currentOntology: OntologySnapshot, currentHash: string): Promise<LockfileValidationResult>;