@objectstack/runtime 4.0.2 → 4.0.4

package/dist/index.cjs

@@ -665,6 +665,13 @@ var AppPlugin = class {
         return;
       }
       ctx.logger.debug("Retrieved ObjectQL engine service", { appId });
+      if (this.bundle.datasourceMapping && Array.isArray(this.bundle.datasourceMapping)) {
+        ctx.logger.info("Configuring datasource mapping rules", {
+          appId,
+          ruleCount: this.bundle.datasourceMapping.length
+        });
+        ql.setDatasourceMapping(this.bundle.datasourceMapping);
+      }
       const runtime = this.bundle.default || this.bundle;
       if (runtime && typeof runtime.onEnable === "function") {
         ctx.logger.info("Executing runtime.onEnable", {
@@ -828,6 +835,7 @@ var AppPlugin = class {
 // src/http-dispatcher.ts
 var import_core2 = require("@objectstack/core");
 var import_system = require("@objectstack/spec/system");
+var import_shared = require("@objectstack/spec/shared");
 function randomUUID() {
   if (globalThis.crypto && typeof globalThis.crypto.randomUUID === "function") {
     return globalThis.crypto.randomUUID();
@@ -839,7 +847,7 @@ function randomUUID() {
   });
 }
 var HttpDispatcher = class {
-  // Casting to any to access dynamic props like broker, services, graphql
+  // Casting to any to access dynamic props like services, graphql
   constructor(kernel) {
     this.kernel = kernel;
   }
@@ -873,11 +881,73 @@ var HttpDispatcher = class {
       }
     };
   }
-  ensureBroker() {
-    if (!this.kernel.broker) {
-      throw { statusCode: 500, message: "Kernel Broker not available" };
-    }
-    return this.kernel.broker;
+  /**
+   * Direct data service dispatch — replaces broker.call('data.*').
+   * Tries protocol service first (supports expand/populate), falls back to ObjectQL.
+   */
+  async callData(action, params) {
+    const protocol = await this.resolveService("protocol");
+    const qlService = await this.getObjectQLService();
+    const ql = qlService ?? await this.resolveService("objectql");
+    if (action === "create") {
+      if (ql) {
+        const res = await ql.insert(params.object, params.data);
+        const record = { ...params.data, ...res };
+        return { object: params.object, id: record.id, record };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "get") {
+      if (protocol && typeof protocol.getData === "function") {
+        return await protocol.getData({ object: params.object, id: params.id, expand: params.expand, select: params.select });
+      }
+      if (ql) {
+        let all = await ql.find(params.object);
+        if (!all) all = [];
+        const match = all.find((i) => i.id === params.id);
+        return match ? { object: params.object, id: params.id, record: match } : null;
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "update") {
+      if (ql && params.id) {
+        let all = await ql.find(params.object);
+        if (all && all.value) all = all.value;
+        if (!all) all = [];
+        const existing = all.find((i) => i.id === params.id);
+        if (!existing) throw new Error("[ObjectStack] Not Found");
+        await ql.update(params.object, params.data, { where: { id: params.id } });
+        return { object: params.object, id: params.id, record: { ...existing, ...params.data } };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "delete") {
+      if (ql) {
+        await ql.delete(params.object, { where: { id: params.id } });
+        return { object: params.object, id: params.id, deleted: true };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "query" || action === "find") {
+      if (protocol && typeof protocol.findData === "function") {
+        const query = params.query || (() => {
+          const { object, ...rest } = params;
+          return rest;
+        })();
+        return await protocol.findData({ object: params.object, query });
+      }
+      if (ql) {
+        let all = await ql.find(params.object);
+        if (!Array.isArray(all) && all && all.value) all = all.value;
+        if (!all) all = [];
+        return { object: params.object, records: all, total: all.length };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "batch") {
+      return { object: params.object, results: [] };
+    }
+    throw { statusCode: 400, message: `Unknown data action: ${action}` };
   }
   /**
    * Generates the discovery JSON response for the API root.
@@ -1041,18 +1111,6 @@ var HttpDispatcher = class {
       return { handled: true, result: response };
     }
     const normalizedPath = path.replace(/^\/+/, "");
-    if (normalizedPath === "login" && method.toUpperCase() === "POST") {
-      try {
-        const broker = this.ensureBroker();
-        const data = await broker.call("auth.login", body, { request: context.request });
-        return { handled: true, response: { status: 200, body: data } };
-      } catch (error) {
-        const statusCode = error?.statusCode ?? error?.status;
-        if (statusCode !== 500 || !error?.message?.includes("Broker not available")) {
-          throw error;
-        }
-      }
-    }
     return this.mockAuthFallback(normalizedPath, method, body);
   }
   /**
@@ -1108,22 +1166,23 @@ var HttpDispatcher = class {
    * Standard: /metadata/:type/:name
    * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
    */
-  async handleMetadata(path, context, method, body, query) {
-    const broker = this.kernel.broker ?? null;
+  async handleMetadata(path, _context, method, body, query) {
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     if (parts[0] === "types") {
+      const metadataService = await this.resolveService("metadata");
+      if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
+        try {
+          const types = await metadataService.getRegisteredTypes();
+          return { handled: true, response: this.success({ types }) };
+        } catch (e) {
+          console.warn("[HttpDispatcher] MetadataService.getRegisteredTypes() failed:", e.message);
+        }
+      }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
         return { handled: true, response: this.success(result) };
       }
-      if (broker) {
-        try {
-          const data = await broker.call("metadata.types", {}, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch {
-        }
-      }
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     if (parts.length === 3 && parts[2] === "published" && (!method || method === "GET")) {
@@ -1134,12 +1193,12 @@ var HttpDispatcher = class {
         if (data === void 0) return { handled: true, response: this.error("Not found", 404) };
         return { handled: true, response: this.success(data) };
       }
-      if (broker) {
+      const metaSvc = await this.resolveService("metadata");
+      if (metaSvc && typeof metaSvc.getPublished === "function") {
         try {
-          const data = await broker.call("metadata.getPublished", { type, name }, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch (e) {
-          return { handled: true, response: this.error(e.message, 404) };
+          const fallbackData = await metaSvc.getPublished(type, name);
+          if (fallbackData !== void 0) return { handled: true, response: this.success(fallbackData) };
+        } catch {
         }
       }
       return { handled: true, response: this.error("Not found", 404) };
@@ -1157,9 +1216,10 @@ var HttpDispatcher = class {
             return { handled: true, response: this.error(e.message, 400) };
           }
         }
-        if (broker) {
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.saveItem === "function") {
           try {
-            const data = await broker.call("metadata.saveItem", { type, name, item: body }, { request: context.request });
+            const data = await metaSvc.saveItem(type, name, body);
             return { handled: true, response: this.success(data) };
           } catch (e) {
             return { handled: true, response: this.error(e.message || "Save not supported", 501) };
@@ -1169,10 +1229,6 @@ var HttpDispatcher = class {
       }
       try {
         if (type === "objects" || type === "object") {
-          if (broker) {
-            const data = await broker.call("metadata.getObject", { objectName: name }, { request: context.request });
-            return { handled: true, response: this.success(data) };
-          }
           const qlService = await this.getObjectQLService();
           if (qlService?.registry) {
             const data = qlService.registry.getObject(name);
@@ -1180,7 +1236,7 @@ var HttpDispatcher = class {
           }
           return { handled: true, response: this.error("Not found", 404) };
         }
-        const singularType = type.endsWith("s") ? type.slice(0, -1) : type;
+        const singularType = (0, import_shared.pluralToSingular)(type);
         const protocol = await this.resolveService("protocol");
         if (protocol && typeof protocol.getMetaItem === "function") {
           try {
@@ -1189,10 +1245,13 @@ var HttpDispatcher = class {
           } catch (e) {
           }
         }
-        if (broker) {
-          const method2 = `metadata.get${this.capitalize(singularType)}`;
-          const data = await broker.call(method2, { name }, { request: context.request });
-          return { handled: true, response: this.success(data) };
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.getItem === "function") {
+          try {
+            const data = await metaSvc.getItem(singularType, name);
+            if (data) return { handled: true, response: this.success(data) };
+          } catch {
+          }
         }
         return { handled: true, response: this.error("Not found", 404) };
       } catch (e) {
@@ -1212,23 +1271,19 @@ var HttpDispatcher = class {
         } catch {
         }
       }
-      if (broker) {
+      const metadataService = await this.getService(import_system.CoreServiceName.enum.metadata);
+      if (metadataService && typeof metadataService.list === "function") {
         try {
-          if (typeOrName === "objects") {
-            const data2 = await broker.call("metadata.objects", { packageId }, { request: context.request });
-            return { handled: true, response: this.success(data2) };
+          let items = await metadataService.list(typeOrName);
+          if (packageId && items && items.length > 0) {
+            items = items.filter((item) => item?._packageId === packageId);
           }
-          const data = await broker.call(`metadata.${typeOrName}`, { packageId }, { request: context.request });
-          if (data !== null && data !== void 0) {
-            return { handled: true, response: this.success(data) };
+          if (items && items.length > 0) {
+            return { handled: true, response: this.success({ type: typeOrName, items }) };
           }
-        } catch {
-        }
-        try {
-          const data = await broker.call("metadata.getObject", { objectName: typeOrName }, { request: context.request });
-          return { handled: true, response: this.success(data) };
         } catch (e) {
-          return { handled: true, response: this.error(e.message, 404) };
+          const sanitizedType = String(typeOrName).replace(/[\r\n\t]/g, "");
+          console.debug(`[HttpDispatcher] MetadataService.list() failed for type:`, sanitizedType, "error:", e.message);
         }
       }
       const qlService = await this.getObjectQLService();
@@ -1247,18 +1302,19 @@ var HttpDispatcher = class {
       return { handled: true, response: this.error("Not found", 404) };
     }
     if (parts.length === 0) {
+      const metadataService = await this.resolveService("metadata");
+      if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
+        try {
+          const types = await metadataService.getRegisteredTypes();
+          return { handled: true, response: this.success({ types }) };
+        } catch {
+        }
+      }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
         return { handled: true, response: this.success(result) };
       }
-      if (broker) {
-        try {
-          const data = await broker.call("metadata.types", {}, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch {
-        }
-      }
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     return { handled: false };
@@ -1267,8 +1323,7 @@ var HttpDispatcher = class {
    * Handles Data requests
    * path: sub-path after /data/ (e.g. "contacts", "contacts/123", "contacts/query")
    */
-  async handleData(path, method, body, query, context) {
-    const broker = this.ensureBroker();
+  async handleData(path, method, body, query, _context) {
     const parts = path.replace(/^\/+/, "").split("/");
     const objectName = parts[0];
     if (!objectName) {
@@ -1278,11 +1333,11 @@ var HttpDispatcher = class {
     if (parts.length > 1) {
       const action = parts[1];
       if (action === "query" && m === "POST") {
-        const result = await broker.call("data.query", { object: objectName, ...body }, { request: context.request });
+        const result = await this.callData("query", { object: objectName, ...body });
         return { handled: true, response: this.success(result) };
       }
       if (action === "batch" && m === "POST") {
-        const result = await broker.call("data.batch", { object: objectName, ...body }, { request: context.request });
+        const result = await this.callData("batch", { object: objectName, ...body });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "GET") {
@@ -1291,17 +1346,17 @@ var HttpDispatcher = class {
         const allowedParams = {};
         if (select != null) allowedParams.select = select;
         if (expand != null) allowedParams.expand = expand;
-        const result = await broker.call("data.get", { object: objectName, id, ...allowedParams }, { request: context.request });
+        const result = await this.callData("get", { object: objectName, id, ...allowedParams });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "PATCH") {
         const id = parts[1];
-        const result = await broker.call("data.update", { object: objectName, id, data: body }, { request: context.request });
+        const result = await this.callData("update", { object: objectName, id, data: body });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "DELETE") {
         const id = parts[1];
-        const result = await broker.call("data.delete", { object: objectName, id }, { request: context.request });
+        const result = await this.callData("delete", { object: objectName, id });
         return { handled: true, response: this.success(result) };
       }
     } else {
@@ -1328,11 +1383,11 @@ var HttpDispatcher = class {
           normalized.offset = normalized.skip;
           delete normalized.skip;
         }
-        const result = await broker.call("data.query", { object: objectName, query: normalized }, { request: context.request });
+        const result = await this.callData("query", { object: objectName, query: normalized });
         return { handled: true, response: this.success(result) };
       }
       if (m === "POST") {
-        const result = await broker.call("data.create", { object: objectName, data: body }, { request: context.request });
+        const result = await this.callData("create", { object: objectName, data: body });
         const res = this.success(result);
         res.status = 201;
         return { handled: true, response: res };
@@ -1434,18 +1489,14 @@ var HttpDispatcher = class {
    * - POST   /packages/:id/publish → publish a package (metadata snapshot)
    * - POST   /packages/:id/revert  → revert a package to last published state
    * 
-   * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service)
-   * with broker fallback for backward compatibility.
+   * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service).
    */
-  async handlePackages(path, method, body, query, context) {
+  async handlePackages(path, method, body, query, _context) {
     const m = method.toUpperCase();
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     const qlService = await this.getObjectQLService();
     const registry = qlService?.registry;
     if (!registry) {
-      if (this.kernel.broker) {
-        return this.handlePackagesViaBroker(parts, m, body, query, context);
-      }
       return { handled: true, response: this.error("Package service not available", 503) };
     }
     try {
@@ -1484,10 +1535,6 @@ var HttpDispatcher = class {
           const result = await metadataService.publishPackage(id, body || {});
           return { handled: true, response: this.success(result) };
         }
-        if (this.kernel.broker) {
-          const result = await this.kernel.broker.call("metadata.publishPackage", { packageId: id, ...body }, { request: context.request });
-          return { handled: true, response: this.success(result) };
-        }
         return { handled: true, response: this.error("Metadata service not available", 503) };
       }
       if (parts.length === 2 && parts[1] === "revert" && m === "POST") {
@@ -1497,10 +1544,6 @@ var HttpDispatcher = class {
           await metadataService.revertPackage(id);
           return { handled: true, response: this.success({ success: true }) };
         }
-        if (this.kernel.broker) {
-          await this.kernel.broker.call("metadata.revertPackage", { packageId: id }, { request: context.request });
-          return { handled: true, response: this.success({ success: true }) };
-        }
         return { handled: true, response: this.error("Metadata service not available", 503) };
       }
       if (parts.length === 1 && m === "GET") {
@@ -1520,47 +1563,6 @@ var HttpDispatcher = class {
     }
     return { handled: false };
   }
-  /**
-   * Fallback: handle packages via broker (for backward compatibility)
-   */
-  async handlePackagesViaBroker(parts, m, body, query, context) {
-    const broker = this.kernel.broker;
-    try {
-      if (parts.length === 0 && m === "GET") {
-        const result = await broker.call("package.list", query || {}, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 0 && m === "POST") {
-        const result = await broker.call("package.install", body, { request: context.request });
-        const res = this.success(result);
-        res.status = 201;
-        return { handled: true, response: res };
-      }
-      if (parts.length === 2 && parts[1] === "enable" && m === "PATCH") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.enable", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 2 && parts[1] === "disable" && m === "PATCH") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.disable", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 1 && m === "GET") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.get", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 1 && m === "DELETE") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.uninstall", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-    } catch (e) {
-      return { handled: true, response: this.error(e.message, e.statusCode || 500) };
-    }
-    return { handled: false };
-  }
   /**
    * Handles Storage requests
    * path: sub-path after /storage/
@@ -1769,9 +1771,6 @@ var HttpDispatcher = class {
     }
     return null;
   }
-  capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-  }
   /**
    * Handle AI service routes (/ai/chat, /ai/models, /ai/conversations, etc.)
    * Resolves the AI service and its built-in route handlers, then dispatches.
@@ -1908,10 +1907,12 @@ var HttpDispatcher = class {
       return this.handleAI(cleanPath, method, body, query, context);
     }
     if (cleanPath === "/openapi.json" && method === "GET") {
-      const broker = this.ensureBroker();
       try {
-        const result2 = await broker.call("metadata.generateOpenApi", {}, { request: context.request });
-        return { handled: true, response: this.success(result2) };
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.generateOpenApi === "function") {
+          const result2 = await metaSvc.generateOpenApi({});
+          return { handled: true, response: this.success(result2) };
+        }
       } catch (e) {
       }
     }
@@ -1926,37 +1927,48 @@ var HttpDispatcher = class {
    * Handles Custom API Endpoints defined in metadata
    */
   async handleApiEndpoint(path, method, body, query, context) {
-    const broker = this.ensureBroker();
     try {
-      const endpoint = await broker.call("metadata.matchEndpoint", { path, method });
+      const metaSvc = await this.resolveService("metadata");
+      if (!metaSvc || typeof metaSvc.matchEndpoint !== "function") {
+        return { handled: false };
+      }
+      const endpoint = await metaSvc.matchEndpoint({ path, method });
       if (endpoint) {
         if (endpoint.type === "flow") {
-          const result = await broker.call("automation.runFlow", {
+          const automationSvc = await this.resolveService("automation");
+          if (!automationSvc || typeof automationSvc.runFlow !== "function") {
+            return { handled: true, response: this.error("Automation service not available", 503) };
+          }
+          const result = await automationSvc.runFlow({
             flowId: endpoint.target,
             inputs: { ...query, ...body, _request: context.request }
           });
           return { handled: true, response: this.success(result) };
         }
         if (endpoint.type === "script") {
-          const result = await broker.call("automation.runScript", {
+          const automationSvc = await this.resolveService("automation");
+          if (!automationSvc || typeof automationSvc.runScript !== "function") {
+            return { handled: true, response: this.error("Automation service not available", 503) };
+          }
+          const result = await automationSvc.runScript({
             scriptName: endpoint.target,
             context: { ...query, ...body, request: context.request }
-          }, { request: context.request });
+          });
           return { handled: true, response: this.success(result) };
         }
         if (endpoint.type === "object_operation") {
           if (endpoint.objectParams) {
             const { object, operation } = endpoint.objectParams;
             if (operation === "find") {
-              const result = await broker.call("data.query", { object, query }, { request: context.request });
+              const result = await this.callData("query", { object, query });
               return { handled: true, response: this.success(result.records, { total: result.total }) };
             }
             if (operation === "get" && query.id) {
-              const result = await broker.call("data.get", { object, id: query.id }, { request: context.request });
+              const result = await this.callData("get", { object, id: query.id });
               return { handled: true, response: this.success(result) };
             }
             if (operation === "create") {
-              const result = await broker.call("data.create", { object, data: body }, { request: context.request });
+              const result = await this.callData("create", { object, data: body });
               return { handled: true, response: this.success(result) };
             }
           }
@@ -1978,6 +1990,64 @@ var HttpDispatcher = class {
 };
 
 // src/dispatcher-plugin.ts
+function mountRouteOnServer(route, server, routePath) {
+  const handler = async (req, res) => {
+    try {
+      const result = await route.handler({
+        body: req.body,
+        params: req.params,
+        query: req.query
+      });
+      if (result.stream && result.events) {
+        res.status(result.status);
+        if (result.headers) {
+          for (const [k, v] of Object.entries(result.headers)) {
+            res.header(k, String(v));
+          }
+        } else {
+          res.header("Content-Type", "text/event-stream");
+          res.header("Cache-Control", "no-cache");
+          res.header("Connection", "keep-alive");
+        }
+        if (typeof res.write === "function" && typeof res.end === "function") {
+          for await (const event of result.events) {
+            res.write(typeof event === "string" ? event : `data: ${JSON.stringify(event)}
+
+`);
+          }
+          res.end();
+        } else {
+          const events = [];
+          for await (const event of result.events) {
+            events.push(event);
+          }
+          res.json({ events });
+        }
+      } else {
+        res.status(result.status);
+        if (result.body !== void 0) {
+          res.json(result.body);
+        } else {
+          res.end();
+        }
+      }
+    } catch (err) {
+      errorResponse(err, res);
+    }
+  };
+  const m = route.method.toLowerCase();
+  if (m === "get" && typeof server.get === "function") {
+    server.get(routePath, handler);
+    return true;
+  } else if (m === "post" && typeof server.post === "function") {
+    server.post(routePath, handler);
+    return true;
+  } else if (m === "delete" && typeof server.delete === "function") {
+    server.delete(routePath, handler);
+    return true;
+  }
+  return false;
+}
 function sendResult(result, res) {
   if (result.handled) {
     if (result.response) {
@@ -2272,61 +2342,23 @@ function createDispatcherPlugin(config = {}) {
         if (!server) return;
         for (const route of routes) {
           const routePath = route.path.startsWith("/api/v1") ? route.path : `${prefix}${route.path}`;
-          const handler = async (req, res) => {
-            try {
-              const result = await route.handler({
-                body: req.body,
-                params: req.params,
-                query: req.query
-              });
-              if (result.stream && result.events) {
-                res.status(result.status);
-                if (result.headers) {
-                  for (const [k, v] of Object.entries(result.headers)) {
-                    res.header(k, v);
-                  }
-                } else {
-                  res.header("Content-Type", "text/event-stream");
-                  res.header("Cache-Control", "no-cache");
-                  res.header("Connection", "keep-alive");
-                }
-                if (typeof res.write === "function" && typeof res.end === "function") {
-                  for await (const event of result.events) {
-                    res.write(typeof event === "string" ? event : `data: ${JSON.stringify(event)}
-
-`);
-                  }
-                  res.end();
-                } else {
-                  const events = [];
-                  for await (const event of result.events) {
-                    events.push(event);
-                  }
-                  res.json({ events });
-                }
-              } else {
-                res.status(result.status);
-                if (result.body !== void 0) {
-                  res.json(result.body);
-                } else {
-                  res.end();
-                }
-              }
-            } catch (err) {
-              errorResponse(err, res);
-            }
-          };
-          const m = route.method.toLowerCase();
-          if (m === "get" && typeof server.get === "function") {
-            server.get(routePath, handler);
-          } else if (m === "post" && typeof server.post === "function") {
-            server.post(routePath, handler);
-          } else if (m === "delete" && typeof server.delete === "function") {
-            server.delete(routePath, handler);
-          }
+          mountRouteOnServer(route, server, routePath);
         }
         ctx.logger.info(`[Dispatcher] Registered ${routes.length} AI routes`);
       });
+      const cachedRoutes = kernel.__aiRoutes;
+      if (cachedRoutes && Array.isArray(cachedRoutes) && cachedRoutes.length > 0) {
+        let registered = 0;
+        for (const route of cachedRoutes) {
+          const routePath = route.path.startsWith("/api/v1") ? route.path : `${prefix}${route.path}`;
+          if (mountRouteOnServer(route, server, routePath)) {
+            registered++;
+          }
+        }
+        if (registered > 0) {
+          ctx.logger.info(`[Dispatcher] Recovered ${registered} cached AI routes (hook timing fallback)`);
+        }
+      }
     }
   };
 }