@celerity-sdk/core 0.3.1 → 0.4.0

package/dist/index.js

@@ -8,18 +8,24 @@ import "reflect-metadata";
 import "reflect-metadata";
 
 // src/metadata/constants.ts
-var CONTROLLER_METADATA = /* @__PURE__ */ Symbol("celerity:controller");
-var HTTP_METHOD_METADATA = /* @__PURE__ */ Symbol("celerity:http-method");
-var ROUTE_PATH_METADATA = /* @__PURE__ */ Symbol("celerity:route-path");
-var PARAM_METADATA = /* @__PURE__ */ Symbol("celerity:param");
-var GUARD_PROTECTEDBY_METADATA = /* @__PURE__ */ Symbol("celerity:guard:protectedBy");
-var GUARD_CUSTOM_METADATA = /* @__PURE__ */ Symbol("celerity:guard:custom");
-var LAYER_METADATA = /* @__PURE__ */ Symbol("celerity:layer");
-var MODULE_METADATA = /* @__PURE__ */ Symbol("celerity:module");
-var INJECTABLE_METADATA = /* @__PURE__ */ Symbol("celerity:injectable");
-var INJECT_METADATA = /* @__PURE__ */ Symbol("celerity:inject");
-var PUBLIC_METADATA = /* @__PURE__ */ Symbol("celerity:public");
-var CUSTOM_METADATA = /* @__PURE__ */ Symbol("celerity:custom-metadata");
+import { INJECT_METADATA, USE_RESOURCE_METADATA } from "@celerity-sdk/common";
+var CONTROLLER_METADATA = /* @__PURE__ */ Symbol.for("celerity:controller");
+var HTTP_METHOD_METADATA = /* @__PURE__ */ Symbol.for("celerity:http-method");
+var ROUTE_PATH_METADATA = /* @__PURE__ */ Symbol.for("celerity:route-path");
+var PARAM_METADATA = /* @__PURE__ */ Symbol.for("celerity:param");
+var GUARD_PROTECTEDBY_METADATA = /* @__PURE__ */ Symbol.for("celerity:guard:protectedBy");
+var GUARD_CUSTOM_METADATA = /* @__PURE__ */ Symbol.for("celerity:guard:custom");
+var LAYER_METADATA = /* @__PURE__ */ Symbol.for("celerity:layer");
+var MODULE_METADATA = /* @__PURE__ */ Symbol.for("celerity:module");
+var INJECTABLE_METADATA = /* @__PURE__ */ Symbol.for("celerity:injectable");
+var PUBLIC_METADATA = /* @__PURE__ */ Symbol.for("celerity:public");
+var CUSTOM_METADATA = /* @__PURE__ */ Symbol.for("celerity:custom-metadata");
+var WEBSOCKET_CONTROLLER_METADATA = /* @__PURE__ */ Symbol.for("celerity:websocket-controller");
+var WEBSOCKET_EVENT_METADATA = /* @__PURE__ */ Symbol.for("celerity:websocket-event");
+var CONSUMER_METADATA = /* @__PURE__ */ Symbol.for("celerity:consumer");
+var CONSUMER_HANDLER_METADATA = /* @__PURE__ */ Symbol.for("celerity:consumer-handler");
+var SCHEDULE_HANDLER_METADATA = /* @__PURE__ */ Symbol.for("celerity:schedule-handler");
+var INVOKE_METADATA = /* @__PURE__ */ Symbol.for("celerity:invoke");
 
 // src/decorators/controller.ts
 function Controller(prefix) {
@@ -114,6 +120,10 @@ function Auth() {
   return createParamDecorator("auth");
 }
 __name(Auth, "Auth");
+function Token() {
+  return createParamDecorator("token");
+}
+__name(Token, "Token");
 function Req() {
   return createParamDecorator("request");
 }
@@ -153,6 +163,9 @@ import "reflect-metadata";
 function Guard(name) {
   return (target) => {
     Reflect.defineMetadata(GUARD_CUSTOM_METADATA, name, target);
+    if (!Reflect.hasOwnMetadata(INJECTABLE_METADATA, target)) {
+      Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+    }
   };
 }
 __name(Guard, "Guard");
@@ -207,6 +220,31 @@ function UseLayers(layers) {
 }
 __name(UseLayers, "UseLayers");
 
+// src/decorators/resource.ts
+import "reflect-metadata";
+function UseResource(...resourceNames) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(USE_RESOURCE_METADATA, target, propertyKey) ?? [];
+      Reflect.defineMetadata(USE_RESOURCE_METADATA, [
+        ...resourceNames,
+        ...existing
+      ], target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(USE_RESOURCE_METADATA, target) ?? [];
+      Reflect.defineMetadata(USE_RESOURCE_METADATA, [
+        ...resourceNames,
+        ...existing
+      ], target);
+    }
+  };
+}
+__name(UseResource, "UseResource");
+function UseResources(resourceNames) {
+  return UseResource(...resourceNames);
+}
+__name(UseResources, "UseResources");
+
 // src/decorators/metadata.ts
 import "reflect-metadata";
 function SetMetadata(key, value) {
@@ -258,6 +296,237 @@ function Module(metadata) {
 }
 __name(Module, "Module");
 
+// src/decorators/websocket.ts
+import "reflect-metadata";
+function WebSocketController() {
+  return (target) => {
+    Reflect.defineMetadata(WEBSOCKET_CONTROLLER_METADATA, true, target);
+    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+  };
+}
+__name(WebSocketController, "WebSocketController");
+function OnConnect() {
+  return (target, propertyKey, descriptor) => {
+    const meta = {
+      eventType: "connect",
+      route: "$connect"
+    };
+    Reflect.defineMetadata(WEBSOCKET_EVENT_METADATA, meta, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(OnConnect, "OnConnect");
+function OnMessage(route) {
+  return (target, propertyKey, descriptor) => {
+    const meta = {
+      eventType: "message",
+      route: route ?? "$default"
+    };
+    Reflect.defineMetadata(WEBSOCKET_EVENT_METADATA, meta, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(OnMessage, "OnMessage");
+function OnDisconnect() {
+  return (target, propertyKey, descriptor) => {
+    const meta = {
+      eventType: "disconnect",
+      route: "$disconnect"
+    };
+    Reflect.defineMetadata(WEBSOCKET_EVENT_METADATA, meta, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(OnDisconnect, "OnDisconnect");
+
+// src/decorators/websocket-params.ts
+import "reflect-metadata";
+function createWsParamDecorator(type, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existing = Reflect.getOwnMetadata(PARAM_METADATA, target, propertyKey) ?? [];
+    const meta = {
+      index: parameterIndex,
+      type
+    };
+    if (schema) meta.schema = schema;
+    existing.push(meta);
+    Reflect.defineMetadata(PARAM_METADATA, existing, target, propertyKey);
+  };
+}
+__name(createWsParamDecorator, "createWsParamDecorator");
+function ConnectionId() {
+  return createWsParamDecorator("connectionId");
+}
+__name(ConnectionId, "ConnectionId");
+function MessageBody(schema) {
+  return createWsParamDecorator("messageBody", schema);
+}
+__name(MessageBody, "MessageBody");
+function MessageId() {
+  return createWsParamDecorator("messageId");
+}
+__name(MessageId, "MessageId");
+function RequestContext() {
+  return createWsParamDecorator("requestContext");
+}
+__name(RequestContext, "RequestContext");
+function EventType() {
+  return createWsParamDecorator("eventType");
+}
+__name(EventType, "EventType");
+
+// src/decorators/consumer.ts
+import "reflect-metadata";
+function Consumer(sourceId) {
+  return (target) => {
+    const meta = {};
+    if (sourceId !== void 0) meta.sourceId = sourceId;
+    Reflect.defineMetadata(CONSUMER_METADATA, meta, target);
+    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+  };
+}
+__name(Consumer, "Consumer");
+function MessageHandler(route) {
+  return (target, propertyKey) => {
+    const meta = {};
+    if (route !== void 0) meta.route = route;
+    Reflect.defineMetadata(CONSUMER_HANDLER_METADATA, meta, target, propertyKey);
+  };
+}
+__name(MessageHandler, "MessageHandler");
+
+// src/decorators/consumer-params.ts
+import "reflect-metadata";
+function createConsumerParamDecorator(type, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existing = Reflect.getOwnMetadata(PARAM_METADATA, target, propertyKey) ?? [];
+    const meta = {
+      index: parameterIndex,
+      type
+    };
+    if (schema) meta.schema = schema;
+    existing.push(meta);
+    Reflect.defineMetadata(PARAM_METADATA, existing, target, propertyKey);
+  };
+}
+__name(createConsumerParamDecorator, "createConsumerParamDecorator");
+function Messages(schema) {
+  return createConsumerParamDecorator("messages", schema);
+}
+__name(Messages, "Messages");
+function EventInput() {
+  return createConsumerParamDecorator("consumerEvent");
+}
+__name(EventInput, "EventInput");
+function Vendor() {
+  return createConsumerParamDecorator("consumerVendor");
+}
+__name(Vendor, "Vendor");
+function ConsumerTraceContext() {
+  return createConsumerParamDecorator("consumerTraceContext");
+}
+__name(ConsumerTraceContext, "ConsumerTraceContext");
+
+// src/decorators/schedule.ts
+import "reflect-metadata";
+function isScheduleExpression(value) {
+  return value.startsWith("rate(") || value.startsWith("cron(");
+}
+__name(isScheduleExpression, "isScheduleExpression");
+function parseScheduleArg(arg) {
+  if (typeof arg === "string") {
+    return isScheduleExpression(arg) ? {
+      schedule: arg
+    } : {
+      scheduleId: arg
+    };
+  }
+  const meta = {};
+  if (arg.scheduleId !== void 0) meta.scheduleId = arg.scheduleId;
+  if (arg.schedule !== void 0) meta.schedule = arg.schedule;
+  return meta;
+}
+__name(parseScheduleArg, "parseScheduleArg");
+function ScheduleHandler(arg) {
+  return (target, propertyKey) => {
+    const meta = arg ? parseScheduleArg(arg) : {};
+    Reflect.defineMetadata(SCHEDULE_HANDLER_METADATA, meta, target, propertyKey);
+  };
+}
+__name(ScheduleHandler, "ScheduleHandler");
+
+// src/decorators/schedule-params.ts
+import "reflect-metadata";
+function createScheduleParamDecorator(type, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existing = Reflect.getOwnMetadata(PARAM_METADATA, target, propertyKey) ?? [];
+    const meta = {
+      index: parameterIndex,
+      type
+    };
+    if (schema) meta.schema = schema;
+    existing.push(meta);
+    Reflect.defineMetadata(PARAM_METADATA, existing, target, propertyKey);
+  };
+}
+__name(createScheduleParamDecorator, "createScheduleParamDecorator");
+function ScheduleInput(schema) {
+  return createScheduleParamDecorator("scheduleInput", schema);
+}
+__name(ScheduleInput, "ScheduleInput");
+function ScheduleId() {
+  return createScheduleParamDecorator("scheduleId");
+}
+__name(ScheduleId, "ScheduleId");
+function ScheduleExpression() {
+  return createScheduleParamDecorator("scheduleExpression");
+}
+__name(ScheduleExpression, "ScheduleExpression");
+function ScheduleEventInput() {
+  return createScheduleParamDecorator("scheduleEvent");
+}
+__name(ScheduleEventInput, "ScheduleEventInput");
+
+// src/decorators/invoke.ts
+import "reflect-metadata";
+function Invoke(name) {
+  return (target, propertyKey) => {
+    const meta = {
+      name
+    };
+    Reflect.defineMetadata(INVOKE_METADATA, meta, target, propertyKey);
+  };
+}
+__name(Invoke, "Invoke");
+
+// src/decorators/invoke-params.ts
+import "reflect-metadata";
+function createInvokeParamDecorator(type, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existing = Reflect.getOwnMetadata(PARAM_METADATA, target, propertyKey) ?? [];
+    const meta = {
+      index: parameterIndex,
+      type
+    };
+    if (schema) meta.schema = schema;
+    existing.push(meta);
+    Reflect.defineMetadata(PARAM_METADATA, existing, target, propertyKey);
+  };
+}
+__name(createInvokeParamDecorator, "createInvokeParamDecorator");
+function Payload(schema) {
+  return createInvokeParamDecorator("payload", schema);
+}
+__name(Payload, "Payload");
+function InvokeContext() {
+  return createInvokeParamDecorator("invokeContext");
+}
+__name(InvokeContext, "InvokeContext");
+
 // src/errors/http-exception.ts
 var HttpException = class extends Error {
   static {
@@ -407,15 +676,48 @@ var GatewayTimeoutException = class extends HttpException {
 };
 
 // src/layers/validate.ts
+function inferMode(schemas) {
+  if (schemas.consumerMessage) return "consumer";
+  if (schemas.scheduleInput) return "schedule";
+  if (schemas.customPayload) return "custom";
+  if (schemas.wsMessageBody) return "websocket";
+  return "http";
+}
+__name(inferMode, "inferMode");
 var ValidationLayer = class ValidationLayer2 {
   static {
     __name(this, "ValidationLayer");
   }
   schemas;
+  mode;
   constructor(schemas) {
     this.schemas = schemas;
+    this.mode = inferMode(schemas);
+  }
+  supports(handlerType) {
+    return handlerType === this.mode;
   }
   async handle(context, next) {
+    switch (this.mode) {
+      case "http":
+        this.validateHttp(context);
+        break;
+      case "websocket":
+        this.validateWebSocket(context);
+        break;
+      case "consumer":
+        this.validateConsumer(context);
+        break;
+      case "schedule":
+        this.validateSchedule(context);
+        break;
+      case "custom":
+        this.validateCustom(context);
+        break;
+    }
+    return next();
+  }
+  validateHttp(context) {
     const { request } = context;
     if (this.schemas.body && request.textBody) {
       try {
@@ -446,7 +748,49 @@ var ValidationLayer = class ValidationLayer2 {
         throw new BadRequestException("Headers validation failed", formatError(error));
       }
     }
-    return next();
+  }
+  validateWebSocket(context) {
+    const schema = this.schemas.wsMessageBody;
+    if (!schema) return;
+    const body = context.message.jsonBody;
+    if (body === void 0) return;
+    context.metadata.set("validatedMessageBody", schema.parse(body));
+  }
+  validateConsumer(context) {
+    const schema = this.schemas.consumerMessage;
+    if (!schema) return;
+    const validated = [];
+    const failures = [];
+    for (const msg of context.event.messages) {
+      try {
+        const parsed = JSON.parse(msg.body);
+        const result = schema.parse(parsed);
+        validated.push({
+          ...msg,
+          parsedBody: result
+        });
+      } catch (err) {
+        failures.push({
+          messageId: msg.messageId,
+          errorMessage: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    context.metadata.set("validatedMessages", validated);
+    if (failures.length > 0) {
+      context.metadata.set("validationFailures", failures);
+    }
+  }
+  validateSchedule(context) {
+    const schema = this.schemas.scheduleInput;
+    if (!schema) return;
+    context.metadata.set("validatedInput", schema.parse(context.event.input));
+  }
+  validateCustom(context) {
+    const schema = this.schemas.customPayload;
+    if (!schema) return;
+    const raw = context.metadata.get("rawPayload");
+    context.metadata.set("validatedPayload", schema.parse(raw));
   }
 };
 function formatError(error) {
@@ -467,9 +811,9 @@ __name(validate, "validate");
 // src/layers/pipeline.ts
 import createDebug from "debug";
 var debug = createDebug("celerity:core:layers");
-function runLayerPipeline(layers, context, handler) {
-  const resolved = layers.map((layer) => typeof layer === "function" ? new layer() : layer);
-  debug("runLayerPipeline: %d layers", resolved.length);
+function runLayerPipeline(layers, context, handler, handlerType) {
+  const resolved = layers.map((layer) => typeof layer === "function" ? new layer() : layer).filter((layer) => !handlerType || !layer.supports || layer.supports(handlerType));
+  debug("runLayerPipeline: %d layers (handlerType=%s)", resolved.length, handlerType ?? "all");
   let index = -1;
   function dispatch(i) {
     if (i <= index) {
@@ -489,7 +833,21 @@ function runLayerPipeline(layers, context, handler) {
 __name(runLayerPipeline, "runLayerPipeline");
 
 // src/layers/system.ts
-import { ConfigLayer } from "@celerity-sdk/config";
+import { ConfigLayer, captureResourceLinks, getResourceTypes } from "@celerity-sdk/config";
+var RESOURCE_LAYER_MAP = {
+  bucket: {
+    pkg: "@celerity-sdk/bucket",
+    className: "ObjectStorageLayer"
+  },
+  queue: {
+    pkg: "@celerity-sdk/queue",
+    className: "QueueLayer"
+  },
+  cache: {
+    pkg: "@celerity-sdk/cache",
+    className: "CacheLayer"
+  }
+};
 async function createDefaultSystemLayers() {
   const layers = [];
   try {
@@ -500,6 +858,19 @@ async function createDefaultSystemLayers() {
   } catch {
   }
   layers.push(new ConfigLayer());
+  const links = captureResourceLinks();
+  const resourceTypes = getResourceTypes(links);
+  for (const type of resourceTypes) {
+    const entry = RESOURCE_LAYER_MAP[type];
+    if (!entry) continue;
+    try {
+      const pkg = entry.pkg;
+      const mod = await import(pkg);
+      const LayerClass = mod[entry.className];
+      layers.push(new LayerClass());
+    } catch {
+    }
+  }
   return layers;
 }
 __name(createDefaultSystemLayers, "createDefaultSystemLayers");
@@ -843,27 +1214,122 @@ var APP_CONFIG = /* @__PURE__ */ Symbol("celerity:app-config");
 var RUNTIME_APP = /* @__PURE__ */ Symbol("celerity:runtime-app");
 
 // src/application/factory.ts
-import createDebug8 from "debug";
+import createDebug17 from "debug";
 
 // src/bootstrap/bootstrap.ts
 import "reflect-metadata";
-import createDebug5 from "debug";
+import createDebug10 from "debug";
 
 // src/handlers/registry.ts
-import "reflect-metadata";
-import createDebug4 from "debug";
-import { joinHandlerPath } from "@celerity-sdk/common";
+import createDebug3 from "debug";
+
+// src/handlers/routing.ts
+function routingKeyOf(handler) {
+  switch (handler.type) {
+    case "http":
+      return `${handler.method} ${handler.path}`;
+    case "websocket":
+      return handler.route;
+    case "consumer":
+      return handler.handlerTag;
+    case "schedule":
+      return handler.handlerTag;
+    case "custom":
+      return handler.name;
+  }
+}
+__name(routingKeyOf, "routingKeyOf");
+
+// src/handlers/registry.ts
+var debug3 = createDebug3("celerity:core:registry");
+var HandlerRegistry = class {
+  static {
+    __name(this, "HandlerRegistry");
+  }
+  byType = /* @__PURE__ */ new Map();
+  exactLookup = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  guards = /* @__PURE__ */ new Map();
+  register(handler) {
+    const list = this.byType.get(handler.type) ?? [];
+    list.push(handler);
+    this.byType.set(handler.type, list);
+    if (handler.type !== "http") {
+      this.exactLookup.set(`${handler.type}::${routingKeyOf(handler)}`, handler);
+    }
+    if (handler.id) {
+      this.byId.set(handler.id, handler);
+    }
+  }
+  getHandler(type, routingKey) {
+    if (type === "http") return this.findHttpHandler(routingKey);
+    const found = this.exactLookup.get(`${type}::${routingKey}`);
+    debug3("getHandler %s %s \u2192 %s", type, routingKey, found ? "matched" : "not found");
+    return found;
+  }
+  getHandlerById(type, id) {
+    const handler = this.byId.get(id);
+    if (handler && handler.type === type) {
+      return handler;
+    }
+    debug3("getHandlerById %s %s \u2192 not found", type, id);
+    return void 0;
+  }
+  getHandlersByType(type) {
+    return this.byType.get(type) ?? [];
+  }
+  getAllHandlers() {
+    const result = [];
+    for (const list of this.byType.values()) result.push(...list);
+    return result;
+  }
+  registerGuard(guard) {
+    debug3("registerGuard: %s", guard.name);
+    this.guards.set(guard.name, guard);
+  }
+  getGuard(name) {
+    const found = this.guards.get(name);
+    debug3("getGuard %s \u2192 %s", name, found ? "matched" : "not found");
+    return found;
+  }
+  getAllGuards() {
+    return [
+      ...this.guards.values()
+    ];
+  }
+  /**
+  * HTTP routing uses path-pattern matching: `"GET /items/{id}"` matches `"GET /items/42"`.
+  * The routing key format is `"METHOD path"` (e.g., `"GET /items/{id}"`).
+  */
+  findHttpHandler(routingKey) {
+    const spaceIdx = routingKey.indexOf(" ");
+    if (spaceIdx < 0) return void 0;
+    const method = routingKey.slice(0, spaceIdx);
+    const path = routingKey.slice(spaceIdx + 1);
+    const httpHandlers = this.byType.get("http") ?? [];
+    const found = httpHandlers.find((h) => h.path !== void 0 && h.method !== void 0 && h.method === method && matchRoute(h.path, path));
+    debug3("getHandler http %s \u2192 %s", routingKey, found ? "matched" : "not found");
+    return found;
+  }
+};
+function matchRoute(pattern, actual) {
+  const patternParts = pattern.split("/").filter(Boolean);
+  const actualParts = actual.split("/").filter(Boolean);
+  if (patternParts.length !== actualParts.length) return false;
+  return patternParts.every((part, i) => part.startsWith("{") || part === actualParts[i]);
+}
+__name(matchRoute, "matchRoute");
 
 // src/bootstrap/module-graph.ts
 import "reflect-metadata";
-import createDebug3 from "debug";
-var debug3 = createDebug3("celerity:core:bootstrap");
+import createDebug4 from "debug";
+var debug4 = createDebug4("celerity:core:bootstrap");
 function buildModuleGraph(rootModule) {
   const graph = /* @__PURE__ */ new Map();
   const resolving = /* @__PURE__ */ new Set();
   function walk(moduleClass, importChain) {
     if (graph.has(moduleClass)) {
-      debug3("walk %s \u2192 already visited", moduleClass.name);
+      debug4("walk %s \u2192 already visited", moduleClass.name);
       return;
     }
     if (resolving.has(moduleClass)) {
@@ -884,6 +1350,7 @@ function buildModuleGraph(rootModule) {
         imports: [],
         controllers: [],
         functionHandlers: [],
+        guards: [],
         providers: []
       });
       return;
@@ -909,9 +1376,15 @@ function buildModuleGraph(rootModule) {
     for (const controller of controllers) {
       ownTokens.add(controller);
     }
+    const guards = metadata.guards ?? [];
+    for (const guard of guards) {
+      if (typeof guard === "function") {
+        ownTokens.add(guard);
+      }
+    }
     const exportTokens = new Set(metadata.exports ?? []);
     resolving.delete(moduleClass);
-    debug3("walk %s: %d providers, %d controllers, %d imports", moduleClass.name, providers.length, controllers.length, imports.length);
+    debug4("walk %s: %d providers, %d controllers, %d guards, %d imports", moduleClass.name, providers.length, controllers.length, guards.length, imports.length);
     graph.set(moduleClass, {
       moduleClass,
       ownTokens,
@@ -919,6 +1392,7 @@ function buildModuleGraph(rootModule) {
       imports,
       controllers,
       functionHandlers: metadata.functionHandlers ?? [],
+      guards,
       providers
     });
   }
@@ -942,6 +1416,11 @@ function registerModuleGraph(graph, container) {
         container.registerClass(controller);
       }
     }
+    for (const guard of node.guards) {
+      if (typeof guard === "function" && !container.has(guard)) {
+        container.registerClass(guard);
+      }
+    }
   }
 }
 __name(registerModuleGraph, "registerModuleGraph");
@@ -988,8 +1467,14 @@ function validateModuleGraph(graph, container) {
       const depTokens = getClassDependencyTokens(controller);
       checkDependencies(controller, depTokens, visibleTokens, node.moduleClass, graph, container, diagnostics);
     }
+    for (const guard of node.guards) {
+      if (typeof guard === "function") {
+        const depTokens = getClassDependencyTokens(guard);
+        checkDependencies(guard, depTokens, visibleTokens, node.moduleClass, graph, container, diagnostics);
+      }
+    }
   }
-  debug3("validateModuleGraph: %d modules, %d diagnostics", graph.size, diagnostics.length);
+  debug4("validateModuleGraph: %d modules, %d diagnostics", graph.size, diagnostics.length);
   if (diagnostics.length > 0) {
     const details = diagnostics.map((d) => `  ${d.message}`).join("\n");
     throw new Error(`Module validation errors:
@@ -1043,131 +1528,165 @@ function findTokenOwner(token, graph) {
 }
 __name(findTokenOwner, "findTokenOwner");
 
-// src/handlers/registry.ts
-var debug4 = createDebug4("celerity:core:registry");
-var HandlerRegistry = class {
-  static {
-    __name(this, "HandlerRegistry");
-  }
-  handlers = [];
-  getHandler(path, method) {
-    const found = this.handlers.find((h) => h.path !== void 0 && h.method !== void 0 && matchRoute(h.path, path) && h.method === method);
-    debug4("getHandler %s %s \u2192 %s", method, path, found ? "matched" : "not found");
-    return found;
-  }
-  getHandlerById(id) {
-    const found = this.handlers.find((h) => h.id !== void 0 && h.id === id);
-    debug4("getHandlerById %s \u2192 %s", id, found ? "matched" : "not found");
-    return found;
-  }
-  getAllHandlers() {
-    return [
-      ...this.handlers
-    ];
-  }
-  async populateFromGraph(graph, container) {
-    for (const [, node] of graph) {
-      for (const controllerClass of node.controllers) {
-        await this.registerClassHandler(controllerClass, container);
-      }
-      for (const fnHandler of node.functionHandlers) {
-        this.registerFunctionHandler(fnHandler);
-      }
+// src/handlers/scanners/http.ts
+import "reflect-metadata";
+import createDebug5 from "debug";
+import { joinHandlerPath } from "@celerity-sdk/common";
+var debug5 = createDebug5("celerity:core:scanner:http");
+async function scanHttpHandlers(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const controllerClass of node.controllers) {
+      await scanClassHandler(controllerClass, container, registry);
+    }
+    for (const fnHandler of node.functionHandlers) {
+      scanFunctionHandler(fnHandler, registry);
     }
   }
-  async scanModule(moduleClass, container) {
-    const graph = buildModuleGraph(moduleClass);
-    registerModuleGraph(graph, container);
-    await this.populateFromGraph(graph, container);
-  }
-  async registerClassHandler(controllerClass, container) {
-    const controllerMeta = Reflect.getOwnMetadata(CONTROLLER_METADATA, controllerClass);
-    if (!controllerMeta) return;
-    const instance = await container.resolve(controllerClass);
-    const prototype = Object.getPrototypeOf(instance);
-    const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
-    const classProtectedBy = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, controllerClass) ?? [];
-    const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
-    const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
-    for (const methodName of methods) {
-      const method = Reflect.getOwnMetadata(HTTP_METHOD_METADATA, prototype, methodName);
-      if (!method) continue;
-      const routePath = Reflect.getOwnMetadata(ROUTE_PATH_METADATA, prototype, methodName) ?? "/";
-      const fullPath = joinHandlerPath(controllerMeta.prefix ?? "", routePath);
-      const methodProtectedBy = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, prototype, methodName) ?? [];
-      const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
-      const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
-      const isPublic = Reflect.getOwnMetadata(PUBLIC_METADATA, prototype, methodName) === true;
-      const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
-      if (!descriptor?.value || typeof descriptor.value !== "function") continue;
-      const layers = [
-        ...classLayers,
-        ...methodLayers
-      ];
-      const validationSchemas = buildValidationSchemasFromParams(paramMetadata);
-      if (validationSchemas) {
-        layers.unshift(validate(validationSchemas));
+}
+__name(scanHttpHandlers, "scanHttpHandlers");
+async function scanHttpGuards(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const guard of node.guards) {
+      if (typeof guard === "function") {
+        await scanClassGuard(guard, container, registry);
+      } else {
+        scanFunctionGuard(guard, registry);
       }
-      debug4("registerClassHandler: %s %s (%s.%s)", method, fullPath, controllerClass.name, methodName);
-      this.handlers.push({
-        path: fullPath,
-        method,
-        protectedBy: [
-          ...classProtectedBy,
-          ...methodProtectedBy
-        ],
-        layers,
-        isPublic,
-        paramMetadata,
-        customMetadata: {
-          ...classCustomMetadata,
-          ...methodCustomMetadata
-        },
-        handlerFn: descriptor.value,
-        handlerInstance: instance
-      });
     }
   }
-  registerFunctionHandler(definition) {
-    if (definition.type !== "http") return;
-    const meta = definition.metadata;
+}
+__name(scanHttpGuards, "scanHttpGuards");
+async function scanModule(moduleClass, container, registry) {
+  const graph = buildModuleGraph(moduleClass);
+  registerModuleGraph(graph, container);
+  await scanHttpHandlers(graph, container, registry);
+  await scanHttpGuards(graph, container, registry);
+}
+__name(scanModule, "scanModule");
+async function scanClassHandler(controllerClass, container, registry) {
+  const controllerMeta = Reflect.getOwnMetadata(CONTROLLER_METADATA, controllerClass);
+  if (!controllerMeta) return;
+  const instance = await container.resolve(controllerClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+  const classProtectedBy = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, controllerClass) ?? [];
+  const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
+  const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
+  for (const methodName of methods) {
+    const method = Reflect.getOwnMetadata(HTTP_METHOD_METADATA, prototype, methodName);
+    if (!method) continue;
+    const routePath = Reflect.getOwnMetadata(ROUTE_PATH_METADATA, prototype, methodName) ?? "/";
+    const fullPath = joinHandlerPath(controllerMeta.prefix ?? "", routePath);
+    const methodProtectedBy = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, prototype, methodName) ?? [];
+    const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
+    const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
+    const isPublic = Reflect.getOwnMetadata(PUBLIC_METADATA, prototype, methodName) === true;
+    const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+    if (!descriptor?.value || typeof descriptor.value !== "function") continue;
     const layers = [
-      ...meta.layers ?? []
+      ...classLayers,
+      ...methodLayers
     ];
-    if (meta.schema) {
-      const schemas = {};
-      if (meta.schema.body) schemas.body = meta.schema.body;
-      if (meta.schema.query) schemas.query = meta.schema.query;
-      if (meta.schema.params) schemas.params = meta.schema.params;
-      if (meta.schema.headers) schemas.headers = meta.schema.headers;
-      if (Object.keys(schemas).length > 0) {
-        layers.unshift(validate(schemas));
-      }
-    }
-    debug4("registerFunctionHandler: %s", definition.id ?? (meta.method && meta.path ? `${meta.method} ${meta.path}` : "(no route)"));
-    this.handlers.push({
-      id: definition.id,
-      path: meta.path,
-      method: meta.method,
-      protectedBy: [],
+    const validationSchemas = buildValidationSchemasFromParams(paramMetadata);
+    if (validationSchemas) {
+      layers.unshift(validate(validationSchemas));
+    }
+    debug5("scanClassHandler: %s %s (%s.%s)", method, fullPath, controllerClass.name, methodName);
+    registry.register({
+      type: "http",
+      path: fullPath,
+      method,
+      protectedBy: [
+        ...classProtectedBy,
+        ...methodProtectedBy
+      ],
       layers,
-      isPublic: false,
-      paramMetadata: [],
-      customMetadata: meta.customMetadata ?? {},
-      handlerFn: definition.handler,
-      isFunctionHandler: true,
-      injectTokens: meta.inject ?? []
+      isPublic,
+      paramMetadata,
+      customMetadata: {
+        ...classCustomMetadata,
+        ...methodCustomMetadata
+      },
+      handlerFn: descriptor.value,
+      handlerInstance: instance
     });
   }
-};
-function matchRoute(pattern, actual) {
-  const patternParts = pattern.split("/").filter(Boolean);
-  const actualParts = actual.split("/").filter(Boolean);
-  if (patternParts.length !== actualParts.length) return false;
-  return patternParts.every((part, i) => part.startsWith("{") || part === actualParts[i]);
 }
-__name(matchRoute, "matchRoute");
+__name(scanClassHandler, "scanClassHandler");
+function scanFunctionHandler(definition, registry) {
+  if (definition.type !== "http") return;
+  const meta = definition.metadata;
+  const layers = [
+    ...meta.layers ?? []
+  ];
+  if (meta.schema) {
+    const schemas = {};
+    if (meta.schema.body) schemas.body = meta.schema.body;
+    if (meta.schema.query) schemas.query = meta.schema.query;
+    if (meta.schema.params) schemas.params = meta.schema.params;
+    if (meta.schema.headers) schemas.headers = meta.schema.headers;
+    if (Object.keys(schemas).length > 0) {
+      layers.unshift(validate(schemas));
+    }
+  }
+  debug5("scanFunctionHandler: %s", definition.id ?? (meta.method && meta.path ? `${meta.method} ${meta.path}` : "(no route)"));
+  registry.register({
+    type: "http",
+    id: definition.id,
+    path: meta.path,
+    method: meta.method,
+    protectedBy: [],
+    layers,
+    isPublic: false,
+    paramMetadata: [],
+    customMetadata: meta.customMetadata ?? {},
+    handlerFn: definition.handler,
+    isFunctionHandler: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionHandler, "scanFunctionHandler");
+async function scanClassGuard(guardClass, container, registry) {
+  const guardName = Reflect.getOwnMetadata(GUARD_CUSTOM_METADATA, guardClass);
+  if (!guardName) return;
+  const instance = await container.resolve(guardClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const descriptor = Object.getOwnPropertyDescriptor(prototype, "check");
+  if (!descriptor?.value || typeof descriptor.value !== "function") {
+    debug5("scanClassGuard: %s has no check() method, skipping", guardClass.name);
+    return;
+  }
+  const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, "check") ?? [];
+  const customMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, guardClass) ?? {};
+  debug5("scanClassGuard: %s (name=%s)", guardClass.name, guardName);
+  registry.registerGuard({
+    name: guardName,
+    handlerFn: descriptor.value,
+    handlerInstance: instance,
+    paramMetadata,
+    customMetadata
+  });
+}
+__name(scanClassGuard, "scanClassGuard");
+function scanFunctionGuard(definition, registry) {
+  const name = definition.name;
+  if (!name) {
+    debug5("scanFunctionGuard: no name, skipping");
+    return;
+  }
+  const meta = definition.metadata ?? {};
+  debug5("scanFunctionGuard: %s", name);
+  registry.registerGuard({
+    name,
+    handlerFn: definition.handler,
+    customMetadata: meta.customMetadata ?? {},
+    paramMetadata: [],
+    isFunctionGuard: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionGuard, "scanFunctionGuard");
 var PARAM_TYPE_TO_SCHEMA_KEY = {
   body: "body",
   query: "query",
@@ -1229,26 +1748,381 @@ function composeKeySchemas(keySchemas) {
 }
 __name(composeKeySchemas, "composeKeySchemas");
 
-// src/bootstrap/bootstrap.ts
-var debug5 = createDebug5("celerity:core:bootstrap");
-async function bootstrap(rootModule) {
-  debug5("bootstrap: starting from %s", rootModule.name);
-  const container = new Container();
-  const registry = new HandlerRegistry();
-  const graph = walkModuleGraph(rootModule, container);
-  validateModuleGraph(graph, container);
-  await registry.populateFromGraph(graph, container);
-  debug5("bootstrap: complete \u2014 %d modules, %d handlers", graph.size, registry.getAllHandlers().length);
-  return {
-    container,
-    registry
-  };
-}
-__name(bootstrap, "bootstrap");
-
-// src/application/application.ts
+// src/handlers/scanners/websocket.ts
+import "reflect-metadata";
 import createDebug6 from "debug";
-var debug6 = createDebug6("celerity:core:factory");
+var debug6 = createDebug6("celerity:core:scanner:websocket");
+async function scanWebSocketHandlers(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const controllerClass of node.controllers) {
+      await scanClassHandler2(controllerClass, container, registry);
+    }
+    for (const fnHandler of node.functionHandlers) {
+      scanFunctionHandler2(fnHandler, registry);
+    }
+  }
+}
+__name(scanWebSocketHandlers, "scanWebSocketHandlers");
+async function scanClassHandler2(controllerClass, container, registry) {
+  const isWsController = Reflect.getOwnMetadata(WEBSOCKET_CONTROLLER_METADATA, controllerClass);
+  if (!isWsController) return;
+  const instance = await container.resolve(controllerClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+  const classProtectedBy = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, controllerClass) ?? [];
+  const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
+  const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
+  const classIsPublic = Reflect.getOwnMetadata(PUBLIC_METADATA, controllerClass) === true;
+  for (const methodName of methods) {
+    const eventMeta = Reflect.getOwnMetadata(WEBSOCKET_EVENT_METADATA, prototype, methodName);
+    if (!eventMeta) continue;
+    const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
+    const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
+    const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+    if (!descriptor?.value || typeof descriptor.value !== "function") continue;
+    debug6("scanClassHandler: %s %s (%s.%s)", eventMeta.eventType, eventMeta.route, controllerClass.name, methodName);
+    const layers = [
+      ...classLayers,
+      ...methodLayers
+    ];
+    const msgBodyParam = paramMetadata.find((p) => p.type === "messageBody");
+    if (msgBodyParam?.schema) {
+      layers.unshift(validate({
+        wsMessageBody: msgBodyParam.schema
+      }));
+    }
+    registry.register({
+      type: "websocket",
+      route: eventMeta.route,
+      protectedBy: classProtectedBy,
+      layers,
+      isPublic: classIsPublic,
+      paramMetadata,
+      customMetadata: {
+        ...classCustomMetadata,
+        ...methodCustomMetadata
+      },
+      handlerFn: descriptor.value,
+      handlerInstance: instance
+    });
+  }
+}
+__name(scanClassHandler2, "scanClassHandler");
+function scanFunctionHandler2(definition, registry) {
+  if (definition.type !== "websocket") return;
+  const meta = definition.metadata;
+  const layers = [
+    ...meta.layers ?? []
+  ];
+  if (meta.schema) {
+    layers.unshift(validate({
+      wsMessageBody: meta.schema
+    }));
+  }
+  debug6("scanFunctionHandler: %s", definition.id ?? meta.route ?? "(no route)");
+  registry.register({
+    type: "websocket",
+    id: definition.id,
+    route: meta.route ?? "$default",
+    protectedBy: meta.protectedBy ?? [],
+    layers,
+    isPublic: false,
+    paramMetadata: [],
+    customMetadata: meta.customMetadata ?? {},
+    handlerFn: definition.handler,
+    isFunctionHandler: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionHandler2, "scanFunctionHandler");
+
+// src/handlers/scanners/consumer.ts
+import "reflect-metadata";
+import createDebug7 from "debug";
+var debug7 = createDebug7("celerity:core:scanner:consumer");
+async function scanConsumerHandlers(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const controllerClass of node.controllers) {
+      await scanClassHandler3(controllerClass, container, registry);
+    }
+    for (const fnHandler of node.functionHandlers) {
+      scanFunctionHandler3(fnHandler, registry);
+    }
+  }
+}
+__name(scanConsumerHandlers, "scanConsumerHandlers");
+async function scanClassHandler3(controllerClass, container, registry) {
+  const consumerMeta = Reflect.getOwnMetadata(CONSUMER_METADATA, controllerClass);
+  if (!consumerMeta) return;
+  const instance = await container.resolve(controllerClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+  const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
+  const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
+  for (const methodName of methods) {
+    const handlerMeta = Reflect.getOwnMetadata(CONSUMER_HANDLER_METADATA, prototype, methodName);
+    if (!handlerMeta) continue;
+    const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
+    const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
+    const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+    if (!descriptor?.value || typeof descriptor.value !== "function") continue;
+    const handlerTag = handlerMeta.route ?? methodName;
+    const layers = [
+      ...classLayers,
+      ...methodLayers
+    ];
+    const messageParam = paramMetadata.find((p) => p.type === "messages");
+    if (messageParam?.schema) {
+      layers.unshift(validate({
+        consumerMessage: messageParam.schema
+      }));
+    }
+    debug7("scanClassHandler: tag=%s (%s.%s)", handlerTag, controllerClass.name, methodName);
+    registry.register({
+      type: "consumer",
+      handlerTag,
+      layers,
+      paramMetadata,
+      customMetadata: {
+        ...classCustomMetadata,
+        ...methodCustomMetadata
+      },
+      handlerFn: descriptor.value,
+      handlerInstance: instance
+    });
+  }
+}
+__name(scanClassHandler3, "scanClassHandler");
+function scanFunctionHandler3(definition, registry) {
+  if (definition.type !== "consumer") return;
+  const meta = definition.metadata;
+  const handlerTag = meta.route ?? definition.id ?? "default";
+  const layers = [
+    ...meta.layers ?? []
+  ];
+  if (meta.messageSchema) {
+    layers.unshift(validate({
+      consumerMessage: meta.messageSchema
+    }));
+  }
+  debug7("scanFunctionHandler: tag=%s", handlerTag);
+  registry.register({
+    type: "consumer",
+    id: definition.id,
+    handlerTag,
+    layers,
+    paramMetadata: [],
+    customMetadata: meta.customMetadata ?? {},
+    handlerFn: definition.handler,
+    isFunctionHandler: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionHandler3, "scanFunctionHandler");
+
+// src/handlers/scanners/schedule.ts
+import "reflect-metadata";
+import createDebug8 from "debug";
+var debug8 = createDebug8("celerity:core:scanner:schedule");
+async function scanScheduleHandlers(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const controllerClass of node.controllers) {
+      await scanClassHandler4(controllerClass, container, registry);
+    }
+    for (const fnHandler of node.functionHandlers) {
+      scanFunctionHandler4(fnHandler, registry);
+    }
+  }
+}
+__name(scanScheduleHandlers, "scanScheduleHandlers");
+async function scanClassHandler4(controllerClass, container, registry) {
+  const instance = await container.resolve(controllerClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+  const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
+  const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
+  for (const methodName of methods) {
+    const handlerMeta = Reflect.getOwnMetadata(SCHEDULE_HANDLER_METADATA, prototype, methodName);
+    if (!handlerMeta) continue;
+    const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
+    const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
+    const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+    if (!descriptor?.value || typeof descriptor.value !== "function") continue;
+    const handlerTag = handlerMeta.scheduleId ?? methodName;
+    const layers = [
+      ...classLayers,
+      ...methodLayers
+    ];
+    const inputParam = paramMetadata.find((p) => p.type === "scheduleInput");
+    if (inputParam?.schema) {
+      layers.unshift(validate({
+        scheduleInput: inputParam.schema
+      }));
+    }
+    debug8("scanClassHandler: tag=%s (%s.%s)", handlerTag, controllerClass.name, methodName);
+    registry.register({
+      type: "schedule",
+      handlerTag,
+      layers,
+      paramMetadata,
+      customMetadata: {
+        ...classCustomMetadata,
+        ...methodCustomMetadata,
+        ...handlerMeta.schedule ? {
+          schedule: handlerMeta.schedule
+        } : {},
+        ...handlerMeta.scheduleId ? {
+          scheduleId: handlerMeta.scheduleId
+        } : {}
+      },
+      handlerFn: descriptor.value,
+      handlerInstance: instance
+    });
+  }
+}
+__name(scanClassHandler4, "scanClassHandler");
+function scanFunctionHandler4(definition, registry) {
+  if (definition.type !== "schedule") return;
+  const meta = definition.metadata;
+  const handlerTag = meta.scheduleId ?? definition.id ?? "default";
+  const layers = [
+    ...meta.layers ?? []
+  ];
+  if (meta.schema) {
+    layers.unshift(validate({
+      scheduleInput: meta.schema
+    }));
+  }
+  const customMetadata = {
+    ...meta.customMetadata ?? {}
+  };
+  if (meta.schedule) customMetadata.schedule = meta.schedule;
+  if (meta.scheduleId) customMetadata.scheduleId = meta.scheduleId;
+  debug8("scanFunctionHandler: tag=%s", handlerTag);
+  registry.register({
+    type: "schedule",
+    id: definition.id,
+    handlerTag,
+    layers,
+    paramMetadata: [],
+    customMetadata,
+    handlerFn: definition.handler,
+    isFunctionHandler: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionHandler4, "scanFunctionHandler");
+
+// src/handlers/scanners/custom.ts
+import "reflect-metadata";
+import createDebug9 from "debug";
+var debug9 = createDebug9("celerity:core:scanner:custom");
+async function scanCustomHandlers(graph, container, registry) {
+  for (const [, node] of graph) {
+    for (const controllerClass of node.controllers) {
+      await scanClassHandler5(controllerClass, container, registry);
+    }
+    for (const fnHandler of node.functionHandlers) {
+      scanFunctionHandler5(fnHandler, registry);
+    }
+  }
+}
+__name(scanCustomHandlers, "scanCustomHandlers");
+async function scanClassHandler5(controllerClass, container, registry) {
+  const instance = await container.resolve(controllerClass);
+  const prototype = Object.getPrototypeOf(instance);
+  const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+  const classLayers = Reflect.getOwnMetadata(LAYER_METADATA, controllerClass) ?? [];
+  const classCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, controllerClass) ?? {};
+  for (const methodName of methods) {
+    const invokeMeta = Reflect.getOwnMetadata(INVOKE_METADATA, prototype, methodName);
+    if (!invokeMeta) continue;
+    const methodLayers = Reflect.getOwnMetadata(LAYER_METADATA, prototype, methodName) ?? [];
+    const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA, prototype, methodName) ?? [];
+    const methodCustomMetadata = Reflect.getOwnMetadata(CUSTOM_METADATA, prototype, methodName) ?? {};
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+    if (!descriptor?.value || typeof descriptor.value !== "function") continue;
+    const layers = [
+      ...classLayers,
+      ...methodLayers
+    ];
+    const payloadParam = paramMetadata.find((p) => p.type === "payload");
+    if (payloadParam?.schema) {
+      layers.unshift(validate({
+        customPayload: payloadParam.schema
+      }));
+    }
+    debug9("scanClassHandler: name=%s (%s.%s)", invokeMeta.name, controllerClass.name, methodName);
+    registry.register({
+      type: "custom",
+      name: invokeMeta.name,
+      layers,
+      paramMetadata,
+      customMetadata: {
+        ...classCustomMetadata,
+        ...methodCustomMetadata
+      },
+      handlerFn: descriptor.value,
+      handlerInstance: instance
+    });
+  }
+}
+__name(scanClassHandler5, "scanClassHandler");
+function scanFunctionHandler5(definition, registry) {
+  if (definition.type !== "custom") return;
+  const meta = definition.metadata;
+  const name = meta.name ?? definition.id ?? "default";
+  const layers = [
+    ...meta.layers ?? []
+  ];
+  if (meta.schema) {
+    layers.unshift(validate({
+      customPayload: meta.schema
+    }));
+  }
+  debug9("scanFunctionHandler: name=%s", name);
+  registry.register({
+    type: "custom",
+    id: definition.id,
+    name,
+    layers,
+    paramMetadata: [],
+    customMetadata: meta.customMetadata ?? {},
+    handlerFn: definition.handler,
+    isFunctionHandler: true,
+    injectTokens: meta.inject ?? []
+  });
+}
+__name(scanFunctionHandler5, "scanFunctionHandler");
+
+// src/bootstrap/bootstrap.ts
+var debug10 = createDebug10("celerity:core:bootstrap");
+async function bootstrap(rootModule) {
+  debug10("bootstrap: starting from %s", rootModule.name);
+  const container = new Container();
+  const registry = new HandlerRegistry();
+  const graph = walkModuleGraph(rootModule, container);
+  validateModuleGraph(graph, container);
+  await scanHttpHandlers(graph, container, registry);
+  await scanHttpGuards(graph, container, registry);
+  await scanWebSocketHandlers(graph, container, registry);
+  await scanConsumerHandlers(graph, container, registry);
+  await scanScheduleHandlers(graph, container, registry);
+  await scanCustomHandlers(graph, container, registry);
+  debug10("bootstrap: complete \u2014 %d modules, %d handlers", graph.size, registry.getAllHandlers().length);
+  return {
+    container,
+    registry
+  };
+}
+__name(bootstrap, "bootstrap");
+
+// src/application/application.ts
+import createDebug11 from "debug";
+var debug11 = createDebug11("celerity:core:factory");
 var CelerityApplication = class {
   static {
     __name(this, "CelerityApplication");
@@ -1272,7 +2146,7 @@ var CelerityApplication = class {
     }
   }
   async close() {
-    debug6("close: shutting down application");
+    debug11("close: shutting down application");
     if (this.runtimeApp && typeof this.runtimeApp === "object") {
       const app = this.runtimeApp;
       await app.shutdown();
@@ -1298,6 +2172,13 @@ var CelerityApplication = class {
 };
 
 // src/application/serverless.ts
+var HANDLER_CREATORS = {
+  http: /* @__PURE__ */ __name((adapter, registry, options) => adapter.createHttpHandler(registry, options), "http"),
+  websocket: /* @__PURE__ */ __name((adapter, registry, options) => adapter.createWebSocketHandler(registry, options), "websocket"),
+  consumer: /* @__PURE__ */ __name((adapter, registry, options) => adapter.createConsumerHandler(registry, options), "consumer"),
+  schedule: /* @__PURE__ */ __name((adapter, registry, options) => adapter.createScheduleHandler(registry, options), "schedule"),
+  custom: /* @__PURE__ */ __name((adapter, registry, options) => adapter.createCustomHandler(registry, options), "custom")
+};
 var ServerlessApplication = class {
   static {
     __name(this, "ServerlessApplication");
@@ -1315,12 +2196,16 @@ var ServerlessApplication = class {
     this.systemLayers = systemLayers;
     this.appLayers = appLayers;
   }
-  async start() {
-    this.handler = this.adapter.createHandler(this.registry, {
+  createHandler(type) {
+    const options = {
       container: this.container,
       systemLayers: this.systemLayers,
       appLayers: this.appLayers
-    });
+    };
+    return HANDLER_CREATORS[type](this.adapter, this.registry, options);
+  }
+  async start(type = "http") {
+    this.handler = this.createHandler(type);
     return this.handler;
   }
   async close() {
@@ -1344,8 +2229,8 @@ var ServerlessApplication = class {
   }
 };
 
-// src/handlers/pipeline.ts
-import createDebug7 from "debug";
+// src/handlers/http-pipeline.ts
+import createDebug12 from "debug";
 
 // src/functions/context.ts
 function buildHttpRequest(request, metadata) {
@@ -1387,12 +2272,17 @@ function buildHttpContext(request, metadata, container, logger) {
 }
 __name(buildHttpContext, "buildHttpContext");
 
-// src/handlers/pipeline.ts
-var debug7 = createDebug7("celerity:core:pipeline");
-async function executeHandlerPipeline(handler, request, options) {
+// src/handlers/http-pipeline.ts
+var debug12 = createDebug12("celerity:core:pipeline");
+async function executeHttpPipeline(handler, request, options) {
   const context = {
     request,
-    metadata: new HandlerMetadataStore(handler.customMetadata ?? {}),
+    metadata: new HandlerMetadataStore({
+      ...handler.customMetadata ?? {},
+      ...options.handlerName ? {
+        handlerName: options.handlerName
+      } : {}
+    }),
     container: options.container
   };
   const allLayers = [
@@ -1400,19 +2290,19 @@ async function executeHandlerPipeline(handler, request, options) {
     ...options.appLayers ?? [],
     ...handler.layers
   ];
-  debug7("%s %s \u2014 %d layers", request.method, request.path, allLayers.length);
+  debug12("%s %s \u2014 %d layers", request.method, request.path, allLayers.length);
   try {
     const response = await runLayerPipeline(allLayers, context, async () => {
-      const handlerType = handler.isFunctionHandler ? "function" : "class";
-      debug7("invoking %s handler", handlerType);
+      const style = handler.isFunctionHandler ? "function" : "class";
+      debug12("invoking %s handler", style);
       const result = handler.isFunctionHandler ? await invokeFunctionHandler(handler, context) : await invokeClassHandler(handler, context);
       return normalizeResponse(result);
-    });
-    debug7("response %d", response.status);
+    }, "http");
+    debug12("response %d", response.status);
     return response;
   } catch (error) {
     if (error instanceof HttpException) {
-      debug7("HttpException %d: %s", error.statusCode, error.message);
+      debug12("HttpException %d: %s", error.statusCode, error.message);
       return {
         status: error.statusCode,
         headers: {
@@ -1448,7 +2338,7 @@ async function executeHandlerPipeline(handler, request, options) {
     };
   }
 }
-__name(executeHandlerPipeline, "executeHandlerPipeline");
+__name(executeHttpPipeline, "executeHttpPipeline");
 async function invokeClassHandler(handler, context) {
   const args = [];
   const sorted = [
@@ -1517,6 +2407,370 @@ function isHttpResponse(value) {
 }
 __name(isHttpResponse, "isHttpResponse");
 
+// src/handlers/websocket-pipeline.ts
+import createDebug13 from "debug";
+var debug13 = createDebug13("celerity:core:ws-pipeline");
+async function executeWebSocketPipeline(handler, message, options) {
+  const context = {
+    message,
+    metadata: new HandlerMetadataStore({
+      ...handler.customMetadata ?? {},
+      ...options.handlerName ? {
+        handlerName: options.handlerName
+      } : {}
+    }),
+    container: options.container
+  };
+  const allLayers = [
+    ...options.systemLayers ?? [],
+    ...options.appLayers ?? [],
+    ...handler.layers
+  ];
+  debug13("%s %s \u2014 %d layers", message.eventType, message.connectionId, allLayers.length);
+  try {
+    await runLayerPipeline(allLayers, context, async () => {
+      const style = handler.isFunctionHandler ? "function" : "class";
+      debug13("invoking %s handler", style);
+      if (handler.isFunctionHandler) {
+        await invokeFunctionHandler2(handler, context);
+      } else {
+        await invokeClassHandler2(handler, context);
+      }
+    }, "websocket");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (context.logger) {
+      context.logger.error("Unhandled error in WebSocket handler pipeline", {
+        error: errorMessage,
+        connectionId: message.connectionId,
+        eventType: message.eventType,
+        ...error instanceof Error && error.stack ? {
+          stack: error.stack
+        } : {}
+      });
+    } else {
+      console.error("Unhandled error in WebSocket handler pipeline:", error);
+    }
+  }
+}
+__name(executeWebSocketPipeline, "executeWebSocketPipeline");
+async function invokeClassHandler2(handler, context) {
+  const args = [];
+  const sorted = [
+    ...handler.paramMetadata
+  ].sort((a, b) => a.index - b.index);
+  for (const meta of sorted) {
+    args[meta.index] = extractWebSocketParam(meta, context);
+  }
+  await handler.handlerFn.apply(handler.handlerInstance, args);
+}
+__name(invokeClassHandler2, "invokeClassHandler");
+async function invokeFunctionHandler2(handler, context) {
+  const validatedBody = context.metadata.get("validatedMessageBody");
+  const message = validatedBody !== void 0 ? {
+    ...context.message,
+    jsonBody: validatedBody
+  } : context.message;
+  if (handler.injectTokens && handler.injectTokens.length > 0) {
+    const deps = [];
+    for (const token of handler.injectTokens) {
+      deps.push(await context.container.resolve(token));
+    }
+    await handler.handlerFn(message, context, ...deps);
+  } else {
+    await handler.handlerFn(message, context);
+  }
+}
+__name(invokeFunctionHandler2, "invokeFunctionHandler");
+function extractWebSocketParam(meta, context) {
+  const { message } = context;
+  switch (meta.type) {
+    case "connectionId":
+      return message.connectionId;
+    case "messageBody": {
+      const validated = context.metadata.get("validatedMessageBody");
+      if (validated !== void 0) return validated;
+      return message.jsonBody;
+    }
+    case "messageId":
+      return message.messageId;
+    case "requestContext":
+      return message.requestContext;
+    case "eventType":
+      return message.eventType;
+    default:
+      return void 0;
+  }
+}
+__name(extractWebSocketParam, "extractWebSocketParam");
+
+// src/handlers/consumer-pipeline.ts
+import createDebug14 from "debug";
+var debug14 = createDebug14("celerity:core:consumer-pipeline");
+async function executeConsumerPipeline(handler, event, options) {
+  const context = {
+    event,
+    metadata: new HandlerMetadataStore({
+      ...handler.customMetadata ?? {},
+      ...options.handlerName ? {
+        handlerName: options.handlerName
+      } : {}
+    }),
+    container: options.container
+  };
+  const allLayers = [
+    ...options.systemLayers ?? [],
+    ...options.appLayers ?? [],
+    ...handler.layers
+  ];
+  debug14("tag=%s \u2014 %d messages, %d layers", event.handlerTag, event.messages.length, allLayers.length);
+  let result = {
+    success: true
+  };
+  try {
+    await runLayerPipeline(allLayers, context, async () => {
+      const style = handler.isFunctionHandler ? "function" : "class";
+      debug14("invoking %s handler", style);
+      const validatedMessages = context.metadata.get("validatedMessages");
+      const validationFailures = context.metadata.get("validationFailures") ?? [];
+      const rawMessages = validatedMessages ? void 0 : event.messages;
+      if (handler.isFunctionHandler) {
+        result = await invokeFunctionHandler3(handler, context, validatedMessages, rawMessages);
+      } else {
+        result = await invokeClassHandler3(handler, context, validatedMessages, rawMessages);
+      }
+      if (validationFailures.length > 0) {
+        const existing = result.failures ?? [];
+        result = {
+          ...result,
+          success: result.success && validationFailures.length === 0,
+          failures: [
+            ...validationFailures,
+            ...existing
+          ]
+        };
+      }
+    }, "consumer");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (context.logger) {
+      context.logger.error("Unhandled error in consumer handler pipeline", {
+        error: errorMessage,
+        handlerTag: event.handlerTag,
+        messageCount: event.messages.length,
+        ...error instanceof Error && error.stack ? {
+          stack: error.stack
+        } : {}
+      });
+    } else {
+      console.error("Unhandled error in consumer handler pipeline:", error);
+    }
+    return {
+      success: false,
+      errorMessage
+    };
+  }
+  return result;
+}
+__name(executeConsumerPipeline, "executeConsumerPipeline");
+async function invokeClassHandler3(handler, context, validatedMessages, rawMessages) {
+  const args = [];
+  const sorted = [
+    ...handler.paramMetadata
+  ].sort((a, b) => a.index - b.index);
+  for (const meta of sorted) {
+    args[meta.index] = extractConsumerParam(meta, context, validatedMessages, rawMessages);
+  }
+  return await handler.handlerFn.apply(handler.handlerInstance, args);
+}
+__name(invokeClassHandler3, "invokeClassHandler");
+async function invokeFunctionHandler3(handler, context, validatedMessages, _rawMessages) {
+  const deps = [];
+  if (handler.injectTokens && handler.injectTokens.length > 0) {
+    for (const token of handler.injectTokens) {
+      deps.push(await context.container.resolve(token));
+    }
+  }
+  const firstArg = validatedMessages ?? context.event;
+  return await handler.handlerFn(firstArg, context, ...deps);
+}
+__name(invokeFunctionHandler3, "invokeFunctionHandler");
+function extractConsumerParam(meta, context, validatedMessages, rawMessages) {
+  switch (meta.type) {
+    case "messages":
+      return validatedMessages ?? rawMessages ?? context.event.messages;
+    case "consumerEvent":
+      return context.event;
+    case "consumerVendor":
+      return context.event.vendor;
+    case "consumerTraceContext":
+      return context.event.traceContext ?? null;
+    default:
+      return void 0;
+  }
+}
+__name(extractConsumerParam, "extractConsumerParam");
+
+// src/handlers/schedule-pipeline.ts
+import createDebug15 from "debug";
+var debug15 = createDebug15("celerity:core:schedule-pipeline");
+async function executeSchedulePipeline(handler, event, options) {
+  const context = {
+    event,
+    metadata: new HandlerMetadataStore({
+      ...handler.customMetadata ?? {},
+      ...options.handlerName ? {
+        handlerName: options.handlerName
+      } : {}
+    }),
+    container: options.container
+  };
+  const allLayers = [
+    ...options.systemLayers ?? [],
+    ...options.appLayers ?? [],
+    ...handler.layers
+  ];
+  debug15("tag=%s \u2014 %d layers", event.handlerTag, allLayers.length);
+  let result = {
+    success: true
+  };
+  try {
+    await runLayerPipeline(allLayers, context, async () => {
+      const style = handler.isFunctionHandler ? "function" : "class";
+      debug15("invoking %s handler", style);
+      const validatedInput = context.metadata.get("validatedInput") ?? event.input;
+      if (handler.isFunctionHandler) {
+        result = await invokeFunctionHandler4(handler, context, validatedInput);
+      } else {
+        result = await invokeClassHandler4(handler, context, validatedInput);
+      }
+    }, "schedule");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (context.logger) {
+      context.logger.error("Unhandled error in schedule handler pipeline", {
+        error: errorMessage,
+        handlerTag: event.handlerTag,
+        scheduleId: event.scheduleId,
+        ...error instanceof Error && error.stack ? {
+          stack: error.stack
+        } : {}
+      });
+    } else {
+      console.error("Unhandled error in schedule handler pipeline:", error);
+    }
+    return {
+      success: false,
+      errorMessage
+    };
+  }
+  return result;
+}
+__name(executeSchedulePipeline, "executeSchedulePipeline");
+async function invokeClassHandler4(handler, context, validatedInput) {
+  const args = [];
+  const sorted = [
+    ...handler.paramMetadata
+  ].sort((a, b) => a.index - b.index);
+  for (const meta of sorted) {
+    args[meta.index] = extractScheduleParam(meta, context, validatedInput);
+  }
+  return await handler.handlerFn.apply(handler.handlerInstance, args);
+}
+__name(invokeClassHandler4, "invokeClassHandler");
+async function invokeFunctionHandler4(handler, context, _validatedInput) {
+  const deps = [];
+  if (handler.injectTokens && handler.injectTokens.length > 0) {
+    for (const token of handler.injectTokens) {
+      deps.push(await context.container.resolve(token));
+    }
+  }
+  return await handler.handlerFn(context.event, context, ...deps);
+}
+__name(invokeFunctionHandler4, "invokeFunctionHandler");
+function extractScheduleParam(meta, context, validatedInput) {
+  switch (meta.type) {
+    case "scheduleInput":
+      return validatedInput;
+    case "scheduleId":
+      return context.event.scheduleId;
+    case "scheduleExpression":
+      return context.event.schedule;
+    case "scheduleEvent":
+      return context.event;
+    default:
+      return void 0;
+  }
+}
+__name(extractScheduleParam, "extractScheduleParam");
+
+// src/handlers/custom-pipeline.ts
+import createDebug16 from "debug";
+var debug16 = createDebug16("celerity:core:custom-pipeline");
+async function executeCustomPipeline(handler, payload, options) {
+  const context = {
+    metadata: new HandlerMetadataStore({
+      ...handler.customMetadata ?? {},
+      ...options.handlerName ? {
+        handlerName: options.handlerName
+      } : {},
+      rawPayload: payload
+    }),
+    container: options.container
+  };
+  const allLayers = [
+    ...options.systemLayers ?? [],
+    ...options.appLayers ?? [],
+    ...handler.layers
+  ];
+  debug16("name=%s \u2014 %d layers", options.handlerName ?? "unknown", allLayers.length);
+  let result;
+  await runLayerPipeline(allLayers, context, async () => {
+    const style = handler.isFunctionHandler ? "function" : "class";
+    debug16("invoking %s handler", style);
+    const validatedPayload = context.metadata.get("validatedPayload") ?? payload;
+    if (handler.isFunctionHandler) {
+      result = await invokeFunctionHandler5(handler, context, validatedPayload);
+    } else {
+      result = await invokeClassHandler5(handler, context, validatedPayload);
+    }
+  }, "custom");
+  return result;
+}
+__name(executeCustomPipeline, "executeCustomPipeline");
+async function invokeClassHandler5(handler, context, validatedPayload) {
+  const args = [];
+  const sorted = [
+    ...handler.paramMetadata
+  ].sort((a, b) => a.index - b.index);
+  for (const meta of sorted) {
+    args[meta.index] = extractCustomParam(meta, context, validatedPayload);
+  }
+  return handler.handlerFn.apply(handler.handlerInstance, args);
+}
+__name(invokeClassHandler5, "invokeClassHandler");
+async function invokeFunctionHandler5(handler, context, validatedPayload) {
+  const deps = [];
+  if (handler.injectTokens && handler.injectTokens.length > 0) {
+    for (const token of handler.injectTokens) {
+      deps.push(await context.container.resolve(token));
+    }
+  }
+  return handler.handlerFn(validatedPayload, context, ...deps);
+}
+__name(invokeFunctionHandler5, "invokeFunctionHandler");
+function extractCustomParam(meta, context, validatedPayload) {
+  switch (meta.type) {
+    case "payload":
+      return validatedPayload;
+    case "invokeContext":
+      return context;
+    default:
+      return void 0;
+  }
+}
+__name(extractCustomParam, "extractCustomParam");
+
 // src/testing/test-app.ts
 var TestingApplication = class {
   static {
@@ -1532,12 +2786,56 @@ var TestingApplication = class {
     this.systemLayers = systemLayers;
     this.appLayers = appLayers;
   }
-  async inject(request) {
-    const handler = this.registry.getHandler(request.path, request.method);
+  async injectHttp(request) {
+    const handler = this.registry.getHandler("http", `${request.method} ${request.path}`);
     if (!handler) {
       throw new NotFoundException(`No handler found for ${request.method} ${request.path}`);
     }
-    return executeHandlerPipeline(handler, request, {
+    return executeHttpPipeline(handler, request, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+  }
+  async injectWebSocket(route, message) {
+    const handler = this.registry.getHandler("websocket", route);
+    if (!handler) {
+      throw new NotFoundException(`No WebSocket handler found for route: ${route}`);
+    }
+    await executeWebSocketPipeline(handler, message, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+  }
+  async injectConsumer(handlerTag, event) {
+    const handler = this.registry.getHandler("consumer", handlerTag);
+    if (!handler) {
+      throw new NotFoundException(`No consumer handler found for tag: ${handlerTag}`);
+    }
+    return executeConsumerPipeline(handler, event, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+  }
+  async injectSchedule(handlerTag, event) {
+    const handler = this.registry.getHandler("schedule", handlerTag);
+    if (!handler) {
+      throw new NotFoundException(`No schedule handler found for tag: ${handlerTag}`);
+    }
+    return executeSchedulePipeline(handler, event, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+  }
+  async injectCustom(name, payload) {
+    const handler = this.registry.getHandler("custom", name);
+    if (!handler) {
+      throw new NotFoundException(`No custom handler found for name: ${name}`);
+    }
+    return executeCustomPipeline(handler, payload ?? null, {
       container: this.container,
       systemLayers: this.systemLayers,
       appLayers: this.appLayers
@@ -1571,28 +2869,77 @@ function mockRequest(method, path, options = {}) {
   };
 }
 __name(mockRequest, "mockRequest");
+function mockWebSocketMessage(options = {}) {
+  return {
+    messageType: options.messageType ?? "json",
+    eventType: options.eventType ?? "message",
+    connectionId: options.connectionId ?? "test-conn-id",
+    messageId: options.messageId ?? "test-msg-id",
+    jsonBody: options.jsonBody ?? null,
+    binaryBody: options.binaryBody,
+    traceContext: options.traceContext ?? null
+  };
+}
+__name(mockWebSocketMessage, "mockWebSocketMessage");
+function mockConsumerEvent(handlerTag, messages, options = {}) {
+  const builtMessages = messages.map((msg, index) => ({
+    messageId: msg.messageId ?? `msg-${index}`,
+    body: msg.body,
+    source: msg.source ?? "test",
+    ...msg.sourceType !== void 0 && {
+      sourceType: msg.sourceType
+    },
+    ...msg.sourceName !== void 0 && {
+      sourceName: msg.sourceName
+    },
+    ...msg.eventType !== void 0 && {
+      eventType: msg.eventType
+    },
+    messageAttributes: msg.messageAttributes ?? {},
+    vendor: {}
+  }));
+  return {
+    handlerTag,
+    messages: builtMessages,
+    vendor: options.vendor ?? {},
+    traceContext: options.traceContext ?? null
+  };
+}
+__name(mockConsumerEvent, "mockConsumerEvent");
+function mockScheduleEvent(handlerTag, options = {}) {
+  return {
+    handlerTag,
+    scheduleId: options.scheduleId ?? handlerTag,
+    messageId: options.messageId ?? "test-schedule-msg-id",
+    schedule: options.schedule ?? "rate(1 day)",
+    input: options.input,
+    vendor: options.vendor ?? {},
+    traceContext: options.traceContext ?? null
+  };
+}
+__name(mockScheduleEvent, "mockScheduleEvent");
 
 // src/application/factory.ts
-var debug8 = createDebug8("celerity:core:factory");
+var debug17 = createDebug17("celerity:core:factory");
 var CelerityFactory = class {
   static {
     __name(this, "CelerityFactory");
   }
   static async create(rootModule, options) {
-    debug8("create: bootstrapping %s", rootModule.name);
+    debug17("create: bootstrapping %s", rootModule.name);
     const systemLayers = options?.systemLayers ?? await createDefaultSystemLayers();
     const appLayers = options?.layers ?? [];
-    debug8("create: %d system layers, %d app layers", systemLayers.length, appLayers.length);
+    debug17("create: %d system layers, %d app layers", systemLayers.length, appLayers.length);
     const { container, registry } = await bootstrap(rootModule);
     if (options?.adapter) {
-      debug8("create: using adapter \u2192 ServerlessApplication");
+      debug17("create: using adapter \u2192 ServerlessApplication");
       return new ServerlessApplication(registry, container, options.adapter, systemLayers, appLayers);
     }
-    debug8("create: \u2192 CelerityApplication");
+    debug17("create: \u2192 CelerityApplication");
     return new CelerityApplication(registry, container, systemLayers, appLayers);
   }
   static async createTestingApp(rootModule, options) {
-    debug8("createTestingApp: bootstrapping %s", rootModule.name);
+    debug17("createTestingApp: bootstrapping %s", rootModule.name);
     const { container, registry } = await bootstrap(rootModule);
     const systemLayers = options?.systemLayers ?? [];
     const appLayers = options?.layers ?? [];
@@ -1689,22 +3036,130 @@ function httpDelete(path, handlerOrOptions, maybeHandler) {
 }
 __name(httpDelete, "httpDelete");
 
+// src/functions/create-guard.ts
+function createGuard(config, handler) {
+  return {
+    __celerity_guard: true,
+    name: config.name,
+    handler,
+    metadata: {
+      inject: config.inject ?? [],
+      customMetadata: config.metadata ?? {}
+    }
+  };
+}
+__name(createGuard, "createGuard");
+
+// src/functions/create-websocket-handler.ts
+function createWebSocketHandler(config, handler) {
+  const metadata = {
+    layers: config.layers ?? [],
+    inject: config.inject ?? [],
+    customMetadata: config.metadata ?? {}
+  };
+  if (config.route !== void 0) metadata.route = config.route;
+  if (config.protectedBy !== void 0) metadata.protectedBy = config.protectedBy;
+  if (config.schema !== void 0) metadata.schema = config.schema;
+  return {
+    __celerity_handler: true,
+    type: "websocket",
+    metadata,
+    handler
+  };
+}
+__name(createWebSocketHandler, "createWebSocketHandler");
+
+// src/functions/create-consumer-handler.ts
+function createConsumerHandler(config, handler) {
+  const metadata = {
+    layers: config.layers ?? [],
+    inject: config.inject ?? [],
+    customMetadata: config.metadata ?? {}
+  };
+  if (config.route !== void 0) metadata.route = config.route;
+  if (config.messageSchema !== void 0) metadata.messageSchema = config.messageSchema;
+  return {
+    __celerity_handler: true,
+    type: "consumer",
+    metadata,
+    handler
+  };
+}
+__name(createConsumerHandler, "createConsumerHandler");
+
+// src/functions/create-schedule-handler.ts
+function isScheduleExpression2(value) {
+  return value.startsWith("rate(") || value.startsWith("cron(");
+}
+__name(isScheduleExpression2, "isScheduleExpression");
+function createScheduleHandler(configOrString, configOrHandler, maybeHandler) {
+  let config;
+  let handler;
+  if (typeof configOrString === "string") {
+    config = {
+      ...configOrHandler
+    };
+    handler = maybeHandler;
+    if (isScheduleExpression2(configOrString)) {
+      config.schedule = configOrString;
+    } else {
+      config.scheduleId = configOrString;
+    }
+  } else {
+    config = configOrString;
+    handler = configOrHandler;
+  }
+  const metadata = {
+    layers: config.layers ?? [],
+    inject: config.inject ?? [],
+    customMetadata: config.metadata ?? {}
+  };
+  if (config.scheduleId !== void 0) metadata.scheduleId = config.scheduleId;
+  if (config.schedule !== void 0) metadata.schedule = config.schedule;
+  if (config.schema !== void 0) metadata.schema = config.schema;
+  return {
+    __celerity_handler: true,
+    type: "schedule",
+    metadata,
+    handler
+  };
+}
+__name(createScheduleHandler, "createScheduleHandler");
+
+// src/functions/create-custom-handler.ts
+function createCustomHandler(config, handler) {
+  const metadata = {
+    layers: config.layers ?? [],
+    inject: config.inject ?? [],
+    customMetadata: config.metadata ?? {}
+  };
+  if (config.name !== void 0) metadata.name = config.name;
+  if (config.schema !== void 0) metadata.schema = config.schema;
+  return {
+    __celerity_handler: true,
+    type: "custom",
+    metadata,
+    handler
+  };
+}
+__name(createCustomHandler, "createCustomHandler");
+
 // src/handlers/module-resolver.ts
 import { resolve } from "path";
-import createDebug9 from "debug";
-var debug9 = createDebug9("celerity:core:module-resolver");
-async function resolveHandlerByModuleRef(handlerId, registry, baseDir) {
+import createDebug18 from "debug";
+var debug18 = createDebug18("celerity:core:module-resolver");
+async function resolveHandlerByModuleRef(handlerId, handlerType, registry, baseDir) {
   const lastDot = handlerId.lastIndexOf(".");
   if (lastDot > 0) {
     const moduleName = handlerId.slice(0, lastDot);
     const exportName = handlerId.slice(lastDot + 1);
-    const result = await tryResolveExport(baseDir, moduleName, exportName, handlerId, registry);
+    const result = await tryResolveExport(baseDir, moduleName, exportName, handlerId, handlerType, registry);
     if (result) return result;
   }
-  return tryResolveExport(baseDir, handlerId, "default", handlerId, registry);
+  return tryResolveExport(baseDir, handlerId, "default", handlerId, handlerType, registry);
 }
 __name(resolveHandlerByModuleRef, "resolveHandlerByModuleRef");
-async function tryResolveExport(baseDir, moduleName, exportName, handlerId, registry) {
+async function tryResolveExport(baseDir, moduleName, exportName, handlerId, handlerType, registry) {
   const handlerModulePath = resolve(baseDir, moduleName);
   let mod;
   try {
@@ -1719,66 +3174,235 @@ async function tryResolveExport(baseDir, moduleName, exportName, handlerId, regi
   const exported = mod[exportName];
   if (!exported) return null;
   const isFnDef = typeof exported === "object" && exported !== null && exported.__celerity_handler;
+  if (isFnDef && exported.type !== handlerType) {
+    return null;
+  }
   const handlerFn = isFnDef ? exported.handler : exported;
   if (typeof handlerFn !== "function") return null;
-  const match = registry.getAllHandlers().find((h) => h.handlerFn === handlerFn);
+  const handlers = registry.getHandlersByType(handlerType);
+  const match = handlers.find((h) => h.handlerFn === handlerFn);
   if (match) {
     match.id = handlerId;
-    debug9("matched '%s' to registry handler", handlerId);
+    debug18("matched '%s' to registry handler", handlerId);
     return match;
   }
-  debug9("'%s' not in registry, wrapping directly", handlerId);
-  return buildResolvedFromExport(handlerId, handlerFn, isFnDef ? exported : null);
+  debug18("'%s' not in registry, wrapping directly", handlerId);
+  return buildResolvedFromExport(handlerId, handlerType, handlerFn, isFnDef ? exported : null);
 }
 __name(tryResolveExport, "tryResolveExport");
-function buildResolvedFromExport(handlerId, handlerFn, fnDef) {
-  if (fnDef) {
-    const meta = fnDef.metadata;
-    return {
-      id: handlerId,
-      protectedBy: [],
-      layers: [
-        ...meta.layers ?? []
-      ],
-      isPublic: false,
-      paramMetadata: [],
-      customMetadata: meta.customMetadata ?? {},
-      handlerFn,
-      isFunctionHandler: true,
-      injectTokens: meta.inject ?? []
-    };
-  }
-  return {
+function buildResolvedFromExport(handlerId, handlerType, handlerFn, fnDef) {
+  const meta = fnDef ? fnDef.metadata : null;
+  const base = {
     id: handlerId,
-    protectedBy: [],
-    layers: [],
-    isPublic: false,
+    layers: [
+      ...meta?.layers ?? []
+    ],
     paramMetadata: [],
-    customMetadata: {},
+    customMetadata: meta?.customMetadata ?? {},
     handlerFn,
     isFunctionHandler: true,
-    injectTokens: []
+    injectTokens: meta?.inject ?? []
+  };
+  const guardFields = {
+    protectedBy: [],
+    isPublic: false
   };
+  switch (handlerType) {
+    case "http":
+      return {
+        ...base,
+        ...guardFields,
+        type: "http",
+        ...meta?.path !== void 0 ? {
+          path: meta.path
+        } : {},
+        ...meta?.method !== void 0 ? {
+          method: meta.method
+        } : {}
+      };
+    case "websocket":
+      return {
+        ...base,
+        ...guardFields,
+        type: "websocket",
+        route: meta?.route ?? handlerId
+      };
+    case "consumer":
+      return {
+        ...base,
+        type: "consumer",
+        handlerTag: meta?.route ?? handlerId
+      };
+    case "schedule":
+      return {
+        ...base,
+        type: "schedule",
+        handlerTag: meta?.scheduleId ?? handlerId
+      };
+    case "custom":
+      return {
+        ...base,
+        type: "custom",
+        name: meta?.name ?? handlerId
+      };
+  }
 }
 __name(buildResolvedFromExport, "buildResolvedFromExport");
 
+// src/handlers/websocket-sender.ts
+var RuntimeWebSocketSender = class {
+  static {
+    __name(this, "RuntimeWebSocketSender");
+  }
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async sendMessage(connectionId, data, options) {
+    const messageId = options?.messageId ?? crypto.randomUUID();
+    const messageType = options?.messageType === "binary" ? "binary" : "json";
+    const payload = typeof data === "string" ? data : JSON.stringify(data);
+    await this.registry.sendMessage(connectionId, messageId, messageType, payload);
+  }
+};
+
+// src/handlers/guard-pipeline.ts
+import createDebug19 from "debug";
+var debug19 = createDebug19("celerity:core:guard-pipeline");
+async function executeGuardPipeline(guard, input, options) {
+  const metadata = new HandlerMetadataStore({
+    ...guard.customMetadata ?? {},
+    ...options.handlerMetadata ?? {}
+  });
+  const logger = await createGuardLogger(guard.name, input, options.container);
+  try {
+    const result = guard.isFunctionGuard ? await invokeFunctionGuard(guard, input, metadata, options, logger) : await invokeClassGuard(guard, input, metadata, options, logger);
+    debug19("guard %s \u2014 allowed", guard.name);
+    return {
+      allowed: true,
+      auth: result ?? {}
+    };
+  } catch (error) {
+    if (error instanceof HttpException) {
+      debug19("guard %s \u2014 rejected %d: %s", guard.name, error.statusCode, error.message);
+      return {
+        allowed: false,
+        statusCode: error.statusCode,
+        message: error.message,
+        details: error.details
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    debug19("guard %s \u2014 unexpected error: %s", guard.name, message);
+    return {
+      allowed: false,
+      statusCode: 401,
+      message: "Unauthorized"
+    };
+  }
+}
+__name(executeGuardPipeline, "executeGuardPipeline");
+async function createGuardLogger(guardName, input, container) {
+  const attrs = {
+    guard: guardName,
+    requestId: input.requestId,
+    method: input.method,
+    path: input.path,
+    clientIp: input.clientIp,
+    ...input.handlerName ? {
+      handlerName: input.handlerName
+    } : {}
+  };
+  if (container.has("CelerityLogger")) {
+    const root = await container.resolve("CelerityLogger");
+    return root.child("guard", attrs);
+  }
+  const pkg = "@celerity-sdk/telemetry";
+  const { createLogger, readTelemetryEnv } = await import(pkg);
+  const rootLogger = await createLogger(readTelemetryEnv());
+  return rootLogger.child("guard", attrs);
+}
+__name(createGuardLogger, "createGuardLogger");
+async function invokeClassGuard(guard, input, metadata, options, logger) {
+  const guardContext = {
+    token: input.token,
+    auth: input.auth,
+    request: {
+      method: input.method,
+      path: input.path,
+      headers: input.headers,
+      query: input.query,
+      cookies: input.cookies,
+      body: input.body,
+      requestId: input.requestId,
+      clientIp: input.clientIp
+    },
+    metadata,
+    container: options.container,
+    logger
+  };
+  const paramCount = guard.handlerFn.length;
+  const args = new Array(paramCount);
+  const decorated = new Set(guard.paramMetadata.map((m) => m.index));
+  for (const meta of guard.paramMetadata) {
+    if (meta.type === "token") {
+      args[meta.index] = guardContext.token;
+    } else if (meta.type === "auth") {
+      args[meta.index] = guardContext.auth;
+    }
+  }
+  for (let i = 0; i < paramCount; i++) {
+    if (!decorated.has(i)) {
+      args[i] = guardContext;
+    }
+  }
+  return guard.handlerFn.apply(guard.handlerInstance, args);
+}
+__name(invokeClassGuard, "invokeClassGuard");
+async function invokeFunctionGuard(guard, input, metadata, options, logger) {
+  const req = {
+    token: input.token,
+    headers: input.headers,
+    query: input.query,
+    cookies: input.cookies,
+    body: input.body,
+    requestId: input.requestId,
+    clientIp: input.clientIp
+  };
+  const ctx = {
+    metadata,
+    container: options.container,
+    auth: input.auth,
+    logger
+  };
+  if (guard.injectTokens && guard.injectTokens.length > 0) {
+    const deps = [];
+    for (const token of guard.injectTokens) {
+      deps.push(await options.container.resolve(token));
+    }
+    return guard.handlerFn(req, ctx, ...deps);
+  }
+  return guard.handlerFn(req, ctx);
+}
+__name(invokeFunctionGuard, "invokeFunctionGuard");
+
 // src/bootstrap/discovery.ts
 import { resolve as resolve2 } from "path";
-import createDebug10 from "debug";
-var debug10 = createDebug10("celerity:core:bootstrap");
+import createDebug20 from "debug";
+var debug20 = createDebug20("celerity:core:bootstrap");
 async function discoverModule(modulePath) {
   const resolved = modulePath ?? process.env.CELERITY_MODULE_PATH;
   if (!resolved) {
     throw new Error("Cannot discover module: set CELERITY_MODULE_PATH environment variable or pass modulePath");
   }
   const absolutePath = resolve2(resolved);
-  debug10("discoverModule: importing %s", absolutePath);
+  debug20("discoverModule: importing %s", absolutePath);
   const imported = await import(absolutePath);
   const rootModule = imported.default ?? findModuleExport(imported);
   if (!rootModule || typeof rootModule !== "function") {
     throw new Error(`No module class found in "${resolved}"`);
   }
-  debug10("discoverModule: found %s", rootModule.name);
+  debug20("discoverModule: found %s", rootModule.name);
   return rootModule;
 }
 __name(discoverModule, "discoverModule");
@@ -1832,61 +3456,350 @@ function mapToRuntimeResponse(response) {
   };
 }
 __name(mapToRuntimeResponse, "mapToRuntimeResponse");
+function mapWebSocketMessage(info) {
+  const requestContext = info.requestContext ? {
+    requestId: info.requestContext.requestId,
+    requestTime: info.requestContext.requestTime,
+    path: info.requestContext.path,
+    protocolVersion: info.requestContext.protocolVersion,
+    headers: flattenMultiValueRecord(info.requestContext.headers),
+    userAgent: info.requestContext.userAgent,
+    clientIp: info.requestContext.clientIp,
+    query: flattenMultiValueRecord(info.requestContext.query),
+    cookies: info.requestContext.cookies,
+    auth: info.requestContext.auth,
+    traceContext: info.requestContext.traceContext
+  } : void 0;
+  return {
+    messageType: info.messageType,
+    eventType: info.eventType,
+    connectionId: info.connectionId,
+    messageId: info.messageId,
+    jsonBody: info.jsonBody,
+    binaryBody: info.binaryBody,
+    requestContext,
+    traceContext: info.traceContext ?? null
+  };
+}
+__name(mapWebSocketMessage, "mapWebSocketMessage");
+function mapConsumerEventInput(input) {
+  return {
+    handlerTag: input.handlerTag,
+    messages: input.messages.map((msg) => {
+      const m = msg;
+      return {
+        messageId: msg.messageId,
+        body: msg.body,
+        source: msg.source,
+        ...m.sourceType !== void 0 && {
+          sourceType: m.sourceType
+        },
+        ...m.sourceName !== void 0 && {
+          sourceName: m.sourceName
+        },
+        ...m.eventType !== void 0 && {
+          eventType: m.eventType
+        },
+        messageAttributes: msg.messageAttributes,
+        vendor: msg.vendor
+      };
+    }),
+    vendor: input.vendor,
+    traceContext: input.traceContext ?? null
+  };
+}
+__name(mapConsumerEventInput, "mapConsumerEventInput");
+function mapScheduleEventInput(input) {
+  return {
+    handlerTag: input.handlerTag,
+    scheduleId: input.scheduleId,
+    messageId: input.messageId,
+    schedule: input.schedule,
+    input: input.input,
+    vendor: input.vendor,
+    traceContext: input.traceContext ?? null
+  };
+}
+__name(mapScheduleEventInput, "mapScheduleEventInput");
+function mapToNapiEventResult(result) {
+  return {
+    success: result.success,
+    failures: result.failures?.map((f) => ({
+      messageId: f.messageId,
+      errorMessage: f.errorMessage
+    })),
+    errorMessage: result.errorMessage
+  };
+}
+__name(mapToNapiEventResult, "mapToNapiEventResult");
 
 // src/bootstrap/runtime-entry.ts
 import { resolve as resolve3, dirname } from "path";
+import createDebug21 from "debug";
+var debug21 = createDebug21("celerity:core:runtime-entry");
 async function bootstrapForRuntime(modulePath, systemLayers) {
   const layers = systemLayers ?? await createDefaultSystemLayers();
   const resolvedModulePath = modulePath ?? process.env.CELERITY_MODULE_PATH;
   const moduleDir = resolvedModulePath ? dirname(resolve3(resolvedModulePath)) : process.cwd();
   const rootModule = await discoverModule(modulePath);
   const { container, registry } = await bootstrap(rootModule);
-  function buildCallback(handler) {
+  function buildHttpCallback(handler, handlerName) {
     if (!handler) return null;
     return async (_err, request) => {
       const httpRequest = mapRuntimeRequest(request);
-      const httpResponse = await executeHandlerPipeline(handler, httpRequest, {
+      const httpResponse = await executeHttpPipeline(handler, httpRequest, {
         container,
-        systemLayers: layers
+        systemLayers: layers,
+        handlerName
       });
       return mapToRuntimeResponse(httpResponse);
     };
   }
-  __name(buildCallback, "buildCallback");
+  __name(buildHttpCallback, "buildHttpCallback");
+  function buildWebSocketCallback(handler, handlerName) {
+    if (!handler) return null;
+    return async (_err, info) => {
+      const message = mapWebSocketMessage(info);
+      await executeWebSocketPipeline(handler, message, {
+        container,
+        systemLayers: layers,
+        handlerName
+      });
+    };
+  }
+  __name(buildWebSocketCallback, "buildWebSocketCallback");
+  function buildConsumerCallback(handler, handlerName) {
+    if (!handler) return null;
+    return async (_err, input) => {
+      const event = mapConsumerEventInput(input);
+      const result = await executeConsumerPipeline(handler, event, {
+        container,
+        systemLayers: layers,
+        handlerName
+      });
+      return mapToNapiEventResult(result);
+    };
+  }
+  __name(buildConsumerCallback, "buildConsumerCallback");
+  function buildScheduleCallback(handler, handlerName) {
+    if (!handler) return null;
+    return async (_err, input) => {
+      const event = mapScheduleEventInput(input);
+      const result = await executeSchedulePipeline(handler, event, {
+        container,
+        systemLayers: layers,
+        handlerName
+      });
+      return mapToNapiEventResult(result);
+    };
+  }
+  __name(buildScheduleCallback, "buildScheduleCallback");
+  function buildCustomCallback(handler, handlerName) {
+    if (!handler) return null;
+    return async (_err, payload) => {
+      return executeCustomPipeline(handler, payload, {
+        container,
+        systemLayers: layers,
+        handlerName
+      });
+    };
+  }
+  __name(buildCustomCallback, "buildCustomCallback");
   return {
     registry,
     container,
-    createRouteCallback(path, method) {
-      return buildCallback(registry.getHandler(path, method));
+    createRouteCallback(method, path, handlerName) {
+      return buildHttpCallback(registry.getHandler("http", `${method} ${path}`), handlerName);
+    },
+    async createRouteCallbackById(handlerId, codeLocation, handlerName) {
+      const fromRegistry = registry.getHandlerById("http", handlerId);
+      if (fromRegistry) return buildHttpCallback(fromRegistry, handlerName);
+      const baseDir = codeLocation ? resolve3(codeLocation) : moduleDir;
+      const resolved = await resolveHandlerByModuleRef(handlerId, "http", registry, baseDir);
+      return resolved ? buildHttpCallback(resolved, handlerName) : null;
+    },
+    createGuardCallback(guardName) {
+      const guard = registry.getGuard(guardName);
+      if (!guard) return null;
+      return async (input) => {
+        debug21("guard %s \u2014 input method=%s path=%s", guardName, input.method, input.path);
+        const handler = registry.getHandler("http", `${input.method} ${input.path}`);
+        debug21("guard %s \u2014 handler %s, customMetadata=%o", guardName, handler ? "found" : "not found", handler?.customMetadata);
+        return executeGuardPipeline(guard, input, {
+          container,
+          handlerMetadata: handler?.customMetadata
+        });
+      };
+    },
+    createWebSocketCallback(route, handlerName) {
+      return buildWebSocketCallback(registry.getHandler("websocket", route), handlerName);
+    },
+    async createWebSocketCallbackById(handlerId, codeLocation, handlerName) {
+      const fromRegistry = registry.getHandlerById("websocket", handlerId);
+      if (fromRegistry) return buildWebSocketCallback(fromRegistry, handlerName);
+      const baseDir = codeLocation ? resolve3(codeLocation) : moduleDir;
+      const resolved = await resolveHandlerByModuleRef(handlerId, "websocket", registry, baseDir);
+      return resolved ? buildWebSocketCallback(resolved, handlerName) : null;
+    },
+    createConsumerCallback(handlerTag, handlerName) {
+      return buildConsumerCallback(registry.getHandler("consumer", handlerTag), handlerName);
+    },
+    async createConsumerCallbackById(handlerId, codeLocation, handlerName) {
+      const fromRegistry = registry.getHandlerById("consumer", handlerId);
+      if (fromRegistry) return buildConsumerCallback(fromRegistry, handlerName);
+      const baseDir = codeLocation ? resolve3(codeLocation) : moduleDir;
+      const resolved = await resolveHandlerByModuleRef(handlerId, "consumer", registry, baseDir);
+      return resolved ? buildConsumerCallback(resolved, handlerName) : null;
+    },
+    createScheduleCallback(handlerTag, handlerName) {
+      return buildScheduleCallback(registry.getHandler("schedule", handlerTag), handlerName);
+    },
+    async createScheduleCallbackById(handlerId, codeLocation, handlerName) {
+      const fromRegistry = registry.getHandlerById("schedule", handlerId);
+      if (fromRegistry) return buildScheduleCallback(fromRegistry, handlerName);
+      const baseDir = codeLocation ? resolve3(codeLocation) : moduleDir;
+      const resolved = await resolveHandlerByModuleRef(handlerId, "schedule", registry, baseDir);
+      return resolved ? buildScheduleCallback(resolved, handlerName) : null;
     },
-    async createRouteCallbackById(handlerId, codeLocation) {
-      const fromRegistry = registry.getHandlerById(handlerId);
-      if (fromRegistry) return buildCallback(fromRegistry);
+    createCustomCallback(handlerName) {
+      return buildCustomCallback(registry.getHandler("custom", handlerName), handlerName);
+    },
+    async createCustomCallbackById(handlerId, codeLocation, handlerName) {
+      const fromRegistry = registry.getHandlerById("custom", handlerId);
+      if (fromRegistry) return buildCustomCallback(fromRegistry, handlerName);
       const baseDir = codeLocation ? resolve3(codeLocation) : moduleDir;
-      const resolved = await resolveHandlerByModuleRef(handlerId, registry, baseDir);
-      return resolved ? buildCallback(resolved) : null;
+      const resolved = await resolveHandlerByModuleRef(handlerId, "custom", registry, baseDir);
+      return resolved ? buildCustomCallback(resolved, handlerName) : null;
     }
   };
 }
 __name(bootstrapForRuntime, "bootstrapForRuntime");
 
 // src/bootstrap/runtime-orchestrator.ts
-async function startRuntime(options) {
+import { WebSocketSender } from "@celerity-sdk/types";
+async function loadRuntime() {
   const pkg = "@celerity-sdk/runtime";
   const runtimeModule = await import(pkg);
   const config = runtimeModule.runtimeConfigFromEnv();
   const app = new runtimeModule.CoreRuntimeApplication(config);
   const appConfig = app.setup();
-  const result = await bootstrapForRuntime();
-  for (const def of appConfig.api?.http?.handlers ?? []) {
-    const callback = result.createRouteCallback(def.path, def.method) ?? await result.createRouteCallbackById(def.handler, def.location);
+  return {
+    app,
+    appConfig
+  };
+}
+__name(loadRuntime, "loadRuntime");
+function mapGuardResult(result) {
+  if (result.allowed) {
+    return {
+      status: "allowed",
+      auth: result.auth
+    };
+  }
+  const status = result.statusCode === 403 ? "forbidden" : "unauthorised";
+  return {
+    status,
+    message: result.message
+  };
+}
+__name(mapGuardResult, "mapGuardResult");
+async function registerHttpHandlers(app, handlers, result) {
+  for (const def of handlers?.http?.handlers ?? []) {
+    const callback = result.createRouteCallback(def.method, def.path, def.name) ?? await result.createRouteCallbackById(def.handler, def.location, def.name);
     if (callback) {
       app.registerHttpHandler(def.path, def.method, def.timeout, callback);
     }
   }
+}
+__name(registerHttpHandlers, "registerHttpHandlers");
+async function registerGuardHandlers(app, guards, result) {
+  for (const guardDef of guards?.handlers ?? []) {
+    const coreCallback = result.createGuardCallback(guardDef.name);
+    if (coreCallback) {
+      await app.registerGuardHandler(guardDef.name, async (_err, input) => {
+        const coreResult = await coreCallback({
+          token: input.token,
+          method: input.request.method,
+          path: input.request.path,
+          headers: input.request.headers,
+          query: input.request.query,
+          cookies: input.request.cookies,
+          body: input.request.body ?? null,
+          requestId: input.request.requestId,
+          clientIp: input.request.clientIp,
+          auth: input.auth ?? {},
+          handlerName: input.handlerName
+        });
+        return mapGuardResult(coreResult);
+      });
+    }
+  }
+}
+__name(registerGuardHandlers, "registerGuardHandlers");
+async function registerWebSocketHandlers(app, websocket, result) {
+  for (const def of websocket?.handlers ?? []) {
+    const callback = result.createWebSocketCallback(def.route, def.name) ?? await result.createWebSocketCallbackById(def.handler, def.location, def.name);
+    if (callback) {
+      app.registerWebsocketHandler(def.route, callback);
+    }
+  }
+}
+__name(registerWebSocketHandlers, "registerWebSocketHandlers");
+async function registerConsumerHandlers(app, consumers, result) {
+  for (const consumer of consumers?.consumers ?? []) {
+    for (const def of consumer.handlers) {
+      const tag = `source::${consumer.sourceId}::${def.name}`;
+      const callback = result.createConsumerCallback(tag, def.name) ?? await result.createConsumerCallbackById(def.handler, def.location, def.name);
+      if (callback) {
+        app.registerConsumerHandler(tag, def.timeout, callback);
+      }
+    }
+  }
+}
+__name(registerConsumerHandlers, "registerConsumerHandlers");
+async function registerScheduleHandlers(app, schedules, result) {
+  for (const schedule of schedules?.schedules ?? []) {
+    for (const def of schedule.handlers) {
+      const tag = `source::${schedule.scheduleId}::${def.name}`;
+      const callback = result.createScheduleCallback(tag, def.name) ?? await result.createScheduleCallbackById(def.handler, def.location, def.name);
+      if (callback) {
+        app.registerScheduleHandler(tag, def.timeout, callback);
+      }
+    }
+  }
+}
+__name(registerScheduleHandlers, "registerScheduleHandlers");
+async function registerCustomHandlers(app, customHandlers, result) {
+  for (const def of customHandlers?.handlers ?? []) {
+    const callback = result.createCustomCallback(def.name) ?? await result.createCustomCallbackById(def.handler, def.location, def.name);
+    if (callback) {
+      app.registerCustomHandler(def.name, def.timeout, callback);
+    }
+  }
+}
+__name(registerCustomHandlers, "registerCustomHandlers");
+async function startRuntime(options) {
+  const { app, appConfig } = await loadRuntime();
+  const result = await bootstrapForRuntime();
+  await registerHttpHandlers(app, appConfig.api, result);
+  await registerGuardHandlers(app, appConfig.api?.guards, result);
+  await registerWebSocketHandlers(app, appConfig.api?.websocket, result);
+  await registerConsumerHandlers(app, appConfig.consumers, result);
+  await registerScheduleHandlers(app, appConfig.schedules, result);
+  await registerCustomHandlers(app, appConfig.customHandlers, result);
+  if (appConfig.api?.websocket) {
+    const sender = new RuntimeWebSocketSender(app.websocketRegistry());
+    result.container.register(WebSocketSender, {
+      useValue: sender
+    });
+  }
   await app.run(options?.block ?? true);
 }
 __name(startRuntime, "startRuntime");
+
+// src/index.ts
+import { WebSocketSender as WebSocketSender2 } from "@celerity-sdk/types";
+import { SourceType, BucketEventType, DatastoreEventType } from "@celerity-sdk/types";
 export {
   APP_CONFIG,
   Action,
@@ -1894,15 +3807,24 @@ export {
   BadGatewayException,
   BadRequestException,
   Body,
+  BucketEventType,
+  CONSUMER_HANDLER_METADATA,
+  CONSUMER_METADATA,
   CONTROLLER_METADATA,
   CUSTOM_METADATA,
   CelerityApplication,
   CelerityFactory,
   ConflictException,
+  ConnectionId,
+  Consumer,
+  ConsumerTraceContext,
   Container,
   Controller,
   Cookies,
+  DatastoreEventType,
   Delete,
+  EventInput,
+  EventType,
   ForbiddenException,
   GUARD_CUSTOM_METADATA,
   GUARD_PROTECTEDBY_METADATA,
@@ -1917,20 +3839,31 @@ export {
   Headers,
   HttpException,
   INJECT_METADATA,
+  INVOKE_METADATA,
   Inject,
   Injectable,
   InternalServerErrorException,
+  Invoke,
+  InvokeContext,
   LAYER_METADATA,
   MODULE_METADATA,
+  MessageBody,
+  MessageHandler,
+  MessageId,
+  Messages,
   MethodNotAllowedException,
   Module,
   NotAcceptableException,
   NotFoundException,
   NotImplementedException,
+  OnConnect,
+  OnDisconnect,
+  OnMessage,
   Options,
   PUBLIC_METADATA,
   Param,
   Patch,
+  Payload,
   Post,
   ProtectedBy,
   Public,
@@ -1939,24 +3872,52 @@ export {
   ROUTE_PATH_METADATA,
   RUNTIME_APP,
   Req,
+  RequestContext,
   RequestId,
+  RuntimeWebSocketSender,
+  SCHEDULE_HANDLER_METADATA,
+  ScheduleEventInput as ScheduleEventInputParam,
+  ScheduleExpression,
+  ScheduleHandler,
+  ScheduleId,
+  ScheduleInput,
   ServerlessApplication,
   ServiceUnavailableException,
   SetMetadata,
+  SourceType,
   TestingApplication,
+  Token,
   TooManyRequestsException,
+  USE_RESOURCE_METADATA,
   UnauthorizedException,
   UnprocessableEntityException,
   UseLayer,
   UseLayers,
+  UseResource,
+  UseResources,
+  Vendor,
+  WEBSOCKET_CONTROLLER_METADATA,
+  WEBSOCKET_EVENT_METADATA,
+  WebSocketController,
+  WebSocketSender2 as WebSocketSender,
   bootstrap,
   bootstrapForRuntime,
   buildModuleGraph,
+  createConsumerHandler,
+  createCustomHandler,
   createDefaultSystemLayers,
+  createGuard,
   createHttpHandler,
+  createScheduleHandler,
+  createWebSocketHandler,
   discoverModule,
   disposeLayers,
-  executeHandlerPipeline,
+  executeConsumerPipeline,
+  executeCustomPipeline,
+  executeGuardPipeline,
+  executeHttpPipeline,
+  executeSchedulePipeline,
+  executeWebSocketPipeline,
   flattenMultiValueRecord,
   getClassDependencyTokens,
   getProviderDependencyTokens,
@@ -1965,12 +3926,27 @@ export {
   httpPatch,
   httpPost,
   httpPut,
+  mapConsumerEventInput,
   mapRuntimeRequest,
+  mapScheduleEventInput,
+  mapToNapiEventResult,
   mapToRuntimeResponse,
+  mapWebSocketMessage,
+  mockConsumerEvent,
   mockRequest,
+  mockScheduleEvent,
+  mockWebSocketMessage,
   registerModuleGraph,
   resolveHandlerByModuleRef,
+  routingKeyOf,
   runLayerPipeline,
+  scanConsumerHandlers,
+  scanCustomHandlers,
+  scanHttpGuards,
+  scanHttpHandlers,
+  scanModule,
+  scanScheduleHandlers,
+  scanWebSocketHandlers,
   startRuntime,
   tokenToString,
   validate