@openverb/runtime 2.0.0-alpha.1 → 2.0.0-alpha.4

package/dist/index.d.mts

@@ -0,0 +1,157 @@
+type Actor = {
+    type: 'user' | 'service' | 'ai' | 'system';
+    id: string;
+    roles?: string[];
+};
+type Context = {
+    tenantId: string;
+    planId: string;
+    env: 'dev' | 'staging' | 'prod';
+    requestId: string;
+};
+type VerbDefinition = {
+    id: string;
+    version: string;
+    summary: string;
+    description?: string;
+    inputSchema: any;
+    outputSchema: any;
+    effects: string[];
+    visibility: 'public' | 'internal' | 'admin';
+    handler: string;
+    policy?: {
+        rolesAllowed?: string[];
+        plansAllowed?: string[];
+    };
+    billing?: {
+        meterKey?: string;
+        defaultDelta?: number;
+    };
+};
+type PolicyDecision = {
+    decision: 'allow';
+    reasons: string[];
+    limits?: Record<string, any>;
+    meter?: {
+        key: string;
+        delta: number;
+    };
+} | {
+    decision: 'deny';
+    reasons: string[];
+    code: string;
+    message: string;
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    };
+};
+type Event = {
+    type: string;
+    timestamp: string;
+    executionId: string;
+    data: Record<string, unknown>;
+};
+type Receipt = {
+    executionId: string;
+    verbId: string;
+    verbVersion: string;
+    timestamp: string;
+    actorId: string;
+    tenantId: string;
+    status: 'ok' | 'denied' | 'error';
+    durationMs: number;
+};
+type HandlerContext = {
+    actor: Actor;
+    context: Context;
+    adapters: Record<string, any>;
+    logger: {
+        info: (message: string, meta?: any) => void;
+        error: (message: string, meta?: any) => void;
+    };
+    emitEvent: (event: Omit<Event, 'timestamp' | 'executionId'>) => void;
+};
+type Handler<TArgs = any, TResult = any> = (ctx: HandlerContext, args: TArgs) => Promise<TResult>;
+type ExecuteRequest = {
+    verbId: string;
+    args: unknown;
+    actor: Actor;
+    context: Context;
+};
+type ExecuteResponse = {
+    ok: true;
+    result: unknown;
+    receipt: Receipt;
+    events: Event[];
+    uiHints?: Array<{
+        type: string;
+        level: string;
+        message: string;
+    }>;
+} | {
+    ok: false;
+    denied: true;
+    reason: {
+        code: string;
+        message: string;
+    };
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    };
+    receipt: Receipt;
+    events: Event[];
+} | {
+    ok: false;
+    error: string;
+    receipt: Receipt;
+    events: Event[];
+};
+type PolicyEngine = (verb: VerbDefinition, actor: Actor, context: Context) => Promise<PolicyDecision>;
+type Runtime = {
+    execute: (req: ExecuteRequest) => Promise<ExecuteResponse>;
+    introspect: () => VerbDefinition[];
+};
+
+type RuntimeConfig = {
+    verbs?: VerbDefinition[];
+    verbsDir?: string;
+    policy: PolicyEngine;
+    handlers: Record<string, Handler>;
+    adapters?: Record<string, any>;
+    onEvent?: (event: Event) => void | Promise<void>;
+    onReceipt?: (receipt: Receipt) => void | Promise<void>;
+};
+declare function createRuntime(config: RuntimeConfig): Runtime;
+
+declare function loadVerbs(verbsDir?: string): VerbDefinition[];
+declare function getVerbById(verbId: string, verbs?: VerbDefinition[]): VerbDefinition | null;
+
+declare function validateInput(schema: any, data: unknown): void;
+declare function validateOutput(schema: any, data: unknown): void;
+
+declare class VerbNotFoundError extends Error {
+    constructor(verbId: string);
+}
+declare class ValidationError extends Error {
+    errors: any[];
+    constructor(message: string, errors: any[]);
+}
+declare class PolicyDeniedError extends Error {
+    code: string;
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    } | undefined;
+    constructor(message: string, code: string, upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    } | undefined);
+}
+declare class HandlerError extends Error {
+    cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+
+export { type Actor, type Context, type Event, type ExecuteRequest, type ExecuteResponse, type Handler, type HandlerContext, HandlerError, type PolicyDecision, PolicyDeniedError, type Receipt, type Runtime, ValidationError, type VerbDefinition, VerbNotFoundError, createRuntime, getVerbById, loadVerbs, validateInput, validateOutput };

package/dist/index.d.ts

@@ -0,0 +1,157 @@
+type Actor = {
+    type: 'user' | 'service' | 'ai' | 'system';
+    id: string;
+    roles?: string[];
+};
+type Context = {
+    tenantId: string;
+    planId: string;
+    env: 'dev' | 'staging' | 'prod';
+    requestId: string;
+};
+type VerbDefinition = {
+    id: string;
+    version: string;
+    summary: string;
+    description?: string;
+    inputSchema: any;
+    outputSchema: any;
+    effects: string[];
+    visibility: 'public' | 'internal' | 'admin';
+    handler: string;
+    policy?: {
+        rolesAllowed?: string[];
+        plansAllowed?: string[];
+    };
+    billing?: {
+        meterKey?: string;
+        defaultDelta?: number;
+    };
+};
+type PolicyDecision = {
+    decision: 'allow';
+    reasons: string[];
+    limits?: Record<string, any>;
+    meter?: {
+        key: string;
+        delta: number;
+    };
+} | {
+    decision: 'deny';
+    reasons: string[];
+    code: string;
+    message: string;
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    };
+};
+type Event = {
+    type: string;
+    timestamp: string;
+    executionId: string;
+    data: Record<string, unknown>;
+};
+type Receipt = {
+    executionId: string;
+    verbId: string;
+    verbVersion: string;
+    timestamp: string;
+    actorId: string;
+    tenantId: string;
+    status: 'ok' | 'denied' | 'error';
+    durationMs: number;
+};
+type HandlerContext = {
+    actor: Actor;
+    context: Context;
+    adapters: Record<string, any>;
+    logger: {
+        info: (message: string, meta?: any) => void;
+        error: (message: string, meta?: any) => void;
+    };
+    emitEvent: (event: Omit<Event, 'timestamp' | 'executionId'>) => void;
+};
+type Handler<TArgs = any, TResult = any> = (ctx: HandlerContext, args: TArgs) => Promise<TResult>;
+type ExecuteRequest = {
+    verbId: string;
+    args: unknown;
+    actor: Actor;
+    context: Context;
+};
+type ExecuteResponse = {
+    ok: true;
+    result: unknown;
+    receipt: Receipt;
+    events: Event[];
+    uiHints?: Array<{
+        type: string;
+        level: string;
+        message: string;
+    }>;
+} | {
+    ok: false;
+    denied: true;
+    reason: {
+        code: string;
+        message: string;
+    };
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    };
+    receipt: Receipt;
+    events: Event[];
+} | {
+    ok: false;
+    error: string;
+    receipt: Receipt;
+    events: Event[];
+};
+type PolicyEngine = (verb: VerbDefinition, actor: Actor, context: Context) => Promise<PolicyDecision>;
+type Runtime = {
+    execute: (req: ExecuteRequest) => Promise<ExecuteResponse>;
+    introspect: () => VerbDefinition[];
+};
+
+type RuntimeConfig = {
+    verbs?: VerbDefinition[];
+    verbsDir?: string;
+    policy: PolicyEngine;
+    handlers: Record<string, Handler>;
+    adapters?: Record<string, any>;
+    onEvent?: (event: Event) => void | Promise<void>;
+    onReceipt?: (receipt: Receipt) => void | Promise<void>;
+};
+declare function createRuntime(config: RuntimeConfig): Runtime;
+
+declare function loadVerbs(verbsDir?: string): VerbDefinition[];
+declare function getVerbById(verbId: string, verbs?: VerbDefinition[]): VerbDefinition | null;
+
+declare function validateInput(schema: any, data: unknown): void;
+declare function validateOutput(schema: any, data: unknown): void;
+
+declare class VerbNotFoundError extends Error {
+    constructor(verbId: string);
+}
+declare class ValidationError extends Error {
+    errors: any[];
+    constructor(message: string, errors: any[]);
+}
+declare class PolicyDeniedError extends Error {
+    code: string;
+    upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    } | undefined;
+    constructor(message: string, code: string, upsell?: {
+        suggestedPlanId: string;
+        cta: string;
+    } | undefined);
+}
+declare class HandlerError extends Error {
+    cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+
+export { type Actor, type Context, type Event, type ExecuteRequest, type ExecuteResponse, type Handler, type HandlerContext, HandlerError, type PolicyDecision, PolicyDeniedError, type Receipt, type Runtime, ValidationError, type VerbDefinition, VerbNotFoundError, createRuntime, getVerbById, loadVerbs, validateInput, validateOutput };

package/dist/index.js

@@ -0,0 +1,245 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HandlerError: () => HandlerError,
+  PolicyDeniedError: () => PolicyDeniedError,
+  ValidationError: () => ValidationError,
+  VerbNotFoundError: () => VerbNotFoundError,
+  createRuntime: () => createRuntime,
+  getVerbById: () => getVerbById,
+  loadVerbs: () => loadVerbs,
+  validateInput: () => validateInput,
+  validateOutput: () => validateOutput
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/engine.ts
+var import_node_crypto = __toESM(require("crypto"));
+
+// src/registry.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var cachedVerbs = null;
+function loadVerbs(verbsDir = "./openverb/verbs") {
+  if (cachedVerbs) return cachedVerbs;
+  const resolvedDir = path.resolve(process.cwd(), verbsDir);
+  if (!fs.existsSync(resolvedDir)) {
+    console.warn(`Verbs directory not found: ${resolvedDir}`);
+    return [];
+  }
+  const files = fs.readdirSync(resolvedDir).filter((f) => f.endsWith(".json"));
+  cachedVerbs = files.map((file) => {
+    const content = fs.readFileSync(path.join(resolvedDir, file), "utf-8");
+    return JSON.parse(content);
+  });
+  return cachedVerbs;
+}
+function getVerbById(verbId, verbs) {
+  const registry = verbs || loadVerbs();
+  return registry.find((v) => v.id === verbId) || null;
+}
+
+// src/validator.ts
+var import_ajv = __toESM(require("ajv"));
+
+// src/errors.ts
+var VerbNotFoundError = class extends Error {
+  constructor(verbId) {
+    super(`Verb not found: ${verbId}`);
+    this.name = "VerbNotFoundError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+};
+var PolicyDeniedError = class extends Error {
+  constructor(message, code, upsell) {
+    super(message);
+    this.code = code;
+    this.upsell = upsell;
+    this.name = "PolicyDeniedError";
+  }
+};
+var HandlerError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "HandlerError";
+  }
+};
+
+// src/validator.ts
+var ajv = new import_ajv.default({ allErrors: true });
+function validateInput(schema, data) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    throw new ValidationError(
+      "Input validation failed",
+      validate.errors || []
+    );
+  }
+}
+function validateOutput(schema, data) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    console.error("Output validation failed:", validate.errors);
+  }
+}
+
+// src/engine.ts
+function createRuntime(config) {
+  const verbs = config.verbs || loadVerbs(config.verbsDir);
+  const events = [];
+  const executionId = import_node_crypto.default.randomUUID();
+  async function execute(req) {
+    const startTime = Date.now();
+    const verb = getVerbById(req.verbId, verbs);
+    if (!verb) {
+      const receipt = createReceipt(req, "error", startTime);
+      return {
+        ok: false,
+        error: `Verb not found: ${req.verbId}`,
+        receipt,
+        events: []
+      };
+    }
+    try {
+      validateInput(verb.inputSchema, req.args);
+      const decision = await config.policy(verb, req.actor, req.context);
+      emitEvent({
+        type: decision.decision === "allow" ? "policy.allowed" : "policy.denied",
+        data: { verbId: verb.id, decision }
+      });
+      if (decision.decision === "deny") {
+        const receipt2 = createReceipt(req, "denied", startTime);
+        await config.onReceipt?.(receipt2);
+        return {
+          ok: false,
+          denied: true,
+          reason: { code: decision.code, message: decision.message },
+          upsell: decision.upsell,
+          receipt: receipt2,
+          events
+        };
+      }
+      const handler = config.handlers[verb.handler];
+      if (!handler) {
+        throw new HandlerError(`Handler not found: ${verb.handler}`);
+      }
+      const ctx = {
+        actor: req.actor,
+        context: req.context,
+        adapters: config.adapters || {},
+        logger: {
+          info: (msg, meta) => console.log(`[INFO] ${msg}`, meta),
+          error: (msg, meta) => console.error(`[ERROR] ${msg}`, meta)
+        },
+        emitEvent
+      };
+      const result = await handler(ctx, req.args);
+      validateOutput(verb.outputSchema, result);
+      const receipt = createReceipt(req, "ok", startTime);
+      await config.onReceipt?.(receipt);
+      return {
+        ok: true,
+        result,
+        receipt,
+        events
+      };
+    } catch (error) {
+      emitEvent({
+        type: "handler.error",
+        data: { error: error instanceof Error ? error.message : "Unknown error" }
+      });
+      const receipt = createReceipt(req, "error", startTime);
+      await config.onReceipt?.(receipt);
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        receipt,
+        events
+      };
+    }
+  }
+  function emitEvent(event) {
+    const fullEvent = {
+      ...event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId
+    };
+    events.push(fullEvent);
+    config.onEvent?.(fullEvent);
+  }
+  function createReceipt(req, status, startTime) {
+    return {
+      executionId,
+      verbId: req.verbId,
+      verbVersion: getVerbById(req.verbId, verbs)?.version || "0.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actorId: req.actor.id,
+      tenantId: req.context.tenantId,
+      status,
+      durationMs: Date.now() - startTime
+    };
+  }
+  function introspect() {
+    return verbs.map((v) => ({
+      id: v.id,
+      version: v.version,
+      summary: v.summary,
+      inputSchema: v.inputSchema,
+      outputSchema: v.outputSchema,
+      effects: v.effects,
+      visibility: v.visibility,
+      handler: v.handler
+    }));
+  }
+  return { execute, introspect };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HandlerError,
+  PolicyDeniedError,
+  ValidationError,
+  VerbNotFoundError,
+  createRuntime,
+  getVerbById,
+  loadVerbs,
+  validateInput,
+  validateOutput
+});

package/dist/index.mjs

@@ -0,0 +1,200 @@
+// src/engine.ts
+import crypto from "crypto";
+
+// src/registry.ts
+import * as fs from "fs";
+import * as path from "path";
+var cachedVerbs = null;
+function loadVerbs(verbsDir = "./openverb/verbs") {
+  if (cachedVerbs) return cachedVerbs;
+  const resolvedDir = path.resolve(process.cwd(), verbsDir);
+  if (!fs.existsSync(resolvedDir)) {
+    console.warn(`Verbs directory not found: ${resolvedDir}`);
+    return [];
+  }
+  const files = fs.readdirSync(resolvedDir).filter((f) => f.endsWith(".json"));
+  cachedVerbs = files.map((file) => {
+    const content = fs.readFileSync(path.join(resolvedDir, file), "utf-8");
+    return JSON.parse(content);
+  });
+  return cachedVerbs;
+}
+function getVerbById(verbId, verbs) {
+  const registry = verbs || loadVerbs();
+  return registry.find((v) => v.id === verbId) || null;
+}
+
+// src/validator.ts
+import Ajv from "ajv";
+
+// src/errors.ts
+var VerbNotFoundError = class extends Error {
+  constructor(verbId) {
+    super(`Verb not found: ${verbId}`);
+    this.name = "VerbNotFoundError";
+  }
+};
+var ValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+};
+var PolicyDeniedError = class extends Error {
+  constructor(message, code, upsell) {
+    super(message);
+    this.code = code;
+    this.upsell = upsell;
+    this.name = "PolicyDeniedError";
+  }
+};
+var HandlerError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "HandlerError";
+  }
+};
+
+// src/validator.ts
+var ajv = new Ajv({ allErrors: true });
+function validateInput(schema, data) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    throw new ValidationError(
+      "Input validation failed",
+      validate.errors || []
+    );
+  }
+}
+function validateOutput(schema, data) {
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    console.error("Output validation failed:", validate.errors);
+  }
+}
+
+// src/engine.ts
+function createRuntime(config) {
+  const verbs = config.verbs || loadVerbs(config.verbsDir);
+  const events = [];
+  const executionId = crypto.randomUUID();
+  async function execute(req) {
+    const startTime = Date.now();
+    const verb = getVerbById(req.verbId, verbs);
+    if (!verb) {
+      const receipt = createReceipt(req, "error", startTime);
+      return {
+        ok: false,
+        error: `Verb not found: ${req.verbId}`,
+        receipt,
+        events: []
+      };
+    }
+    try {
+      validateInput(verb.inputSchema, req.args);
+      const decision = await config.policy(verb, req.actor, req.context);
+      emitEvent({
+        type: decision.decision === "allow" ? "policy.allowed" : "policy.denied",
+        data: { verbId: verb.id, decision }
+      });
+      if (decision.decision === "deny") {
+        const receipt2 = createReceipt(req, "denied", startTime);
+        await config.onReceipt?.(receipt2);
+        return {
+          ok: false,
+          denied: true,
+          reason: { code: decision.code, message: decision.message },
+          upsell: decision.upsell,
+          receipt: receipt2,
+          events
+        };
+      }
+      const handler = config.handlers[verb.handler];
+      if (!handler) {
+        throw new HandlerError(`Handler not found: ${verb.handler}`);
+      }
+      const ctx = {
+        actor: req.actor,
+        context: req.context,
+        adapters: config.adapters || {},
+        logger: {
+          info: (msg, meta) => console.log(`[INFO] ${msg}`, meta),
+          error: (msg, meta) => console.error(`[ERROR] ${msg}`, meta)
+        },
+        emitEvent
+      };
+      const result = await handler(ctx, req.args);
+      validateOutput(verb.outputSchema, result);
+      const receipt = createReceipt(req, "ok", startTime);
+      await config.onReceipt?.(receipt);
+      return {
+        ok: true,
+        result,
+        receipt,
+        events
+      };
+    } catch (error) {
+      emitEvent({
+        type: "handler.error",
+        data: { error: error instanceof Error ? error.message : "Unknown error" }
+      });
+      const receipt = createReceipt(req, "error", startTime);
+      await config.onReceipt?.(receipt);
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        receipt,
+        events
+      };
+    }
+  }
+  function emitEvent(event) {
+    const fullEvent = {
+      ...event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId
+    };
+    events.push(fullEvent);
+    config.onEvent?.(fullEvent);
+  }
+  function createReceipt(req, status, startTime) {
+    return {
+      executionId,
+      verbId: req.verbId,
+      verbVersion: getVerbById(req.verbId, verbs)?.version || "0.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actorId: req.actor.id,
+      tenantId: req.context.tenantId,
+      status,
+      durationMs: Date.now() - startTime
+    };
+  }
+  function introspect() {
+    return verbs.map((v) => ({
+      id: v.id,
+      version: v.version,
+      summary: v.summary,
+      inputSchema: v.inputSchema,
+      outputSchema: v.outputSchema,
+      effects: v.effects,
+      visibility: v.visibility,
+      handler: v.handler
+    }));
+  }
+  return { execute, introspect };
+}
+export {
+  HandlerError,
+  PolicyDeniedError,
+  ValidationError,
+  VerbNotFoundError,
+  createRuntime,
+  getVerbById,
+  loadVerbs,
+  validateInput,
+  validateOutput
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openverb/runtime",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.4",
   "description": "OpenVerb execution runtime",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -12,6 +12,9 @@
       "import": "./dist/index.mjs"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",

package/src/engine.ts

@@ -1,166 +0,0 @@
-import crypto from 'node:crypto'
-import { loadVerbs, getVerbById } from './registry'
-import { validateInput, validateOutput } from './validator'
-import { VerbNotFoundError, PolicyDeniedError, HandlerError } from './errors'
-import type {
-  Runtime,
-  ExecuteRequest,
-  ExecuteResponse,
-  VerbDefinition,
-  PolicyEngine,
-  Handler,
-  Event,
-  Receipt,
-  HandlerContext
-} from './types'
-
-type RuntimeConfig = {
-  verbs?: VerbDefinition[]
-  verbsDir?: string
-  policy: PolicyEngine
-  handlers: Record<string, Handler>
-  adapters?: Record<string, any>
-  onEvent?: (event: Event) => void | Promise<void>
-  onReceipt?: (receipt: Receipt) => void | Promise<void>
-}
-
-export function createRuntime(config: RuntimeConfig): Runtime {
-  const verbs = config.verbs || loadVerbs(config.verbsDir)
-  const events: Event[] = []
-  const executionId = crypto.randomUUID()
-
-  async function execute(req: ExecuteRequest): Promise<ExecuteResponse> {
-    const startTime = Date.now()
-    
-    // Stage 1: Resolve verb
-    const verb = getVerbById(req.verbId, verbs)
-    if (!verb) {
-      const receipt = createReceipt(req, 'error', startTime)
-      return {
-        ok: false,
-        error: `Verb not found: ${req.verbId}`,
-        receipt,
-        events: []
-      }
-    }
-
-    try {
-      // Stage 2: Validate input
-      validateInput(verb.inputSchema, req.args)
-
-      // Stage 3: Policy check
-      const decision = await config.policy(verb, req.actor, req.context)
-      
-      emitEvent({
-        type: decision.decision === 'allow' ? 'policy.allowed' : 'policy.denied',
-        data: { verbId: verb.id, decision }
-      })
-
-      if (decision.decision === 'deny') {
-        const receipt = createReceipt(req, 'denied', startTime)
-        await config.onReceipt?.(receipt)
-        
-        return {
-          ok: false,
-          denied: true,
-          reason: { code: decision.code, message: decision.message },
-          upsell: decision.upsell,
-          receipt,
-          events
-        }
-      }
-
-      // Stage 4: Execute handler
-      const handler = config.handlers[verb.handler]
-      if (!handler) {
-        throw new HandlerError(`Handler not found: ${verb.handler}`)
-      }
-
-      const ctx: HandlerContext = {
-        actor: req.actor,
-        context: req.context,
-        adapters: config.adapters || {},
-        logger: {
-          info: (msg, meta) => console.log(`[INFO] ${msg}`, meta),
-          error: (msg, meta) => console.error(`[ERROR] ${msg}`, meta)
-        },
-        emitEvent
-      }
-
-      const result = await handler(ctx, req.args)
-
-      // Stage 5: Validate output
-      validateOutput(verb.outputSchema, result)
-
-      // Stage 6: Create receipt
-      const receipt = createReceipt(req, 'ok', startTime)
-      await config.onReceipt?.(receipt)
-
-      // Stage 7: Return response
-      return {
-        ok: true,
-        result,
-        receipt,
-        events
-      }
-
-    } catch (error) {
-      emitEvent({
-        type: 'handler.error',
-        data: { error: error instanceof Error ? error.message : 'Unknown error' }
-      })
-
-      const receipt = createReceipt(req, 'error', startTime)
-      await config.onReceipt?.(receipt)
-
-      return {
-        ok: false,
-        error: error instanceof Error ? error.message : 'Unknown error',
-        receipt,
-        events
-      }
-    }
-  }
-
-  function emitEvent(event: Omit<Event, 'timestamp' | 'executionId'>) {
-    const fullEvent: Event = {
-      ...event,
-      timestamp: new Date().toISOString(),
-      executionId
-    }
-    events.push(fullEvent)
-    config.onEvent?.(fullEvent)
-  }
-
-  function createReceipt(
-    req: ExecuteRequest,
-    status: 'ok' | 'denied' | 'error',
-    startTime: number
-  ): Receipt {
-    return {
-      executionId,
-      verbId: req.verbId,
-      verbVersion: getVerbById(req.verbId, verbs)?.version || '0.0.0',
-      timestamp: new Date().toISOString(),
-      actorId: req.actor.id,
-      tenantId: req.context.tenantId,
-      status,
-      durationMs: Date.now() - startTime
-    }
-  }
-
-  function introspect(): VerbDefinition[] {
-    return verbs.map(v => ({
-      id: v.id,
-      version: v.version,
-      summary: v.summary,
-      inputSchema: v.inputSchema,
-      outputSchema: v.outputSchema,
-      effects: v.effects,
-      visibility: v.visibility,
-      handler: v.handler
-    }))
-  }
-
-  return { execute, introspect }
-}

package/src/errors.ts

@@ -1,31 +0,0 @@
-export class VerbNotFoundError extends Error {
-  constructor(verbId: string) {
-    super(`Verb not found: ${verbId}`)
-    this.name = 'VerbNotFoundError'
-  }
-}
-
-export class ValidationError extends Error {
-  constructor(message: string, public errors: any[]) {
-    super(message)
-    this.name = 'ValidationError'
-  }
-}
-
-export class PolicyDeniedError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public upsell?: { suggestedPlanId: string; cta: string }
-  ) {
-    super(message)
-    this.name = 'PolicyDeniedError'
-  }
-}
-
-export class HandlerError extends Error {
-  constructor(message: string, public cause?: Error) {
-    super(message)
-    this.name = 'HandlerError'
-  }
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-// @openverb/runtime - Main entry point
-export { createRuntime } from './engine'
-export { loadVerbs, getVerbById } from './registry'
-export { validateInput, validateOutput } from './validator'
-export type {
-  Runtime,
-  ExecuteRequest,
-  ExecuteResponse,
-  VerbDefinition,
-  HandlerContext,
-  Handler,
-  Actor,
-  Context,
-  Receipt,
-  Event,
-  PolicyDecision
-} from './types'
-export { VerbNotFoundError, ValidationError, PolicyDeniedError, HandlerError } from './errors'

package/src/registry.ts

@@ -1,34 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import type { VerbDefinition } from './types'
-
-let cachedVerbs: VerbDefinition[] | null = null
-
-export function loadVerbs(verbsDir: string = './openverb/verbs'): VerbDefinition[] {
-  if (cachedVerbs) return cachedVerbs
-
-  const resolvedDir = path.resolve(process.cwd(), verbsDir)
-  
-  if (!fs.existsSync(resolvedDir)) {
-    console.warn(`Verbs directory not found: ${resolvedDir}`)
-    return []
-  }
-
-  const files = fs.readdirSync(resolvedDir).filter(f => f.endsWith('.json'))
-  
-  cachedVerbs = files.map(file => {
-    const content = fs.readFileSync(path.join(resolvedDir, file), 'utf-8')
-    return JSON.parse(content) as VerbDefinition
-  })
-
-  return cachedVerbs
-}
-
-export function getVerbById(verbId: string, verbs?: VerbDefinition[]): VerbDefinition | null {
-  const registry = verbs || loadVerbs()
-  return registry.find(v => v.id === verbId) || null
-}
-
-export function clearCache() {
-  cachedVerbs = null
-}

package/src/types.ts

@@ -1,128 +0,0 @@
-import type { JSONSchemaType } from 'ajv'
-
-// Core types
-export type Actor = {
-  type: 'user' | 'service' | 'ai' | 'system'
-  id: string
-  roles?: string[]
-}
-
-export type Context = {
-  tenantId: string
-  planId: string
-  env: 'dev' | 'staging' | 'prod'
-  requestId: string
-}
-
-export type VerbDefinition = {
-  id: string
-  version: string
-  summary: string
-  description?: string
-  inputSchema: any  // JSON Schema
-  outputSchema: any // JSON Schema
-  effects: string[]
-  visibility: 'public' | 'internal' | 'admin'
-  handler: string
-  policy?: {
-    rolesAllowed?: string[]
-    plansAllowed?: string[]
-  }
-  billing?: {
-    meterKey?: string
-    defaultDelta?: number
-  }
-}
-
-export type PolicyDecision =
-  | {
-      decision: 'allow'
-      reasons: string[]
-      limits?: Record<string, any>
-      meter?: { key: string; delta: number }
-    }
-  | {
-      decision: 'deny'
-      reasons: string[]
-      code: string
-      message: string
-      upsell?: {
-        suggestedPlanId: string
-        cta: string
-      }
-    }
-
-export type Event = {
-  type: string
-  timestamp: string
-  executionId: string
-  data: Record<string, unknown>
-}
-
-export type Receipt = {
-  executionId: string
-  verbId: string
-  verbVersion: string
-  timestamp: string
-  actorId: string
-  tenantId: string
-  status: 'ok' | 'denied' | 'error'
-  durationMs: number
-}
-
-export type HandlerContext = {
-  actor: Actor
-  context: Context
-  adapters: Record<string, any>
-  logger: {
-    info: (message: string, meta?: any) => void
-    error: (message: string, meta?: any) => void
-  }
-  emitEvent: (event: Omit<Event, 'timestamp' | 'executionId'>) => void
-}
-
-export type Handler<TArgs = any, TResult = any> = (
-  ctx: HandlerContext,
-  args: TArgs
-) => Promise<TResult>
-
-export type ExecuteRequest = {
-  verbId: string
-  args: unknown
-  actor: Actor
-  context: Context
-}
-
-export type ExecuteResponse =
-  | {
-      ok: true
-      result: unknown
-      receipt: Receipt
-      events: Event[]
-      uiHints?: Array<{ type: string; level: string; message: string }>
-    }
-  | {
-      ok: false
-      denied: true
-      reason: { code: string; message: string }
-      upsell?: { suggestedPlanId: string; cta: string }
-      receipt: Receipt
-      events: Event[]
-    }
-  | {
-      ok: false
-      error: string
-      receipt: Receipt
-      events: Event[]
-    }
-
-export type PolicyEngine = (
-  verb: VerbDefinition,
-  actor: Actor,
-  context: Context
-) => Promise<PolicyDecision>
-
-export type Runtime = {
-  execute: (req: ExecuteRequest) => Promise<ExecuteResponse>
-  introspect: () => VerbDefinition[]
-}

package/src/validator.ts

@@ -1,26 +0,0 @@
-import Ajv from 'ajv'
-import { ValidationError } from './errors'
-
-const ajv = new Ajv({ allErrors: true })
-
-export function validateInput(schema: any, data: unknown): void {
-  const validate = ajv.compile(schema)
-  const valid = validate(data)
-  
-  if (!valid) {
-    throw new ValidationError(
-      'Input validation failed',
-      validate.errors || []
-    )
-  }
-}
-
-export function validateOutput(schema: any, data: unknown): void {
-  const validate = ajv.compile(schema)
-  const valid = validate(data)
-  
-  if (!valid) {
-    console.error('Output validation failed:', validate.errors)
-    // Don't throw - log warning instead
-  }
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}