@celerity-sdk/cli 0.3.1 → 0.5.0

package/README.md

@@ -24,6 +24,23 @@ The Go-based Celerity CLI invokes this tool during the build phase to merge code
 2. **Serialization** (`serializeManifest`) - converts scanned metadata into a structured manifest with handler entries, annotations, and a dependency graph.
 3. **Validation** (`validateScannedDependencies`) - checks that all provider dependencies are resolvable, reporting diagnostics for missing tokens.
 
+## Supported Handler Types
+
+The extraction tool produces manifest entries for both **class-based** (decorator-driven) and **function-based** (blueprint-driven) handlers across all handler types:
+
+| Handler Type | Class Decorator | Function Type | Description |
+|---|---|---|---|
+| HTTP | `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete` | `"http"` | REST API route handlers |
+| WebSocket | `@OnConnect`, `@OnDisconnect`, `@OnMessage` | `"websocket"` | WebSocket event handlers |
+| Consumer | `@ConsumerHandler` | `"consumer"` | Queue/topic message consumers |
+| Schedule | `@ScheduleHandler` | `"schedule"` | Cron/rate scheduled handlers |
+| Custom | `@Invoke` | `"custom"` | Direct invocation handlers |
+| Guard | `@Guard` (class) or `defineGuard` (function) | — | Custom guard implementations |
+
+### Cross-Cutting Decorators
+
+`@ScheduleHandler` and `@Invoke` are cross-cutting — they can be applied to methods on any controller type (HTTP, WebSocket, or Consumer), producing additional manifest entries alongside the primary handler entry.
+
 ## Manifest Structure
 
 The output conforms to `handler-manifest.v1.schema.json`:
@@ -51,24 +68,108 @@ The output conforms to `handler-manifest.v1.schema.json`:
       }
     }
   ],
-  "functionHandlers": [],
+  "functionHandlers": [
+    {
+      "resourceName": "processOrder",
+      "exportName": "processOrder",
+      "handlerType": "consumer",
+      "sourceFile": "/project/src/app.module.ts",
+      "annotations": {
+        "celerity.handler.consumer": true,
+        "celerity.handler.consumer.route": "orders.*"
+      },
+      "spec": {
+        "handlerName": "processOrder",
+        "codeLocation": "./src",
+        "handler": "app.module.processOrder"
+      }
+    }
+  ],
+  "guardHandlers": [
+    {
+      "resourceName": "rateLimiter_check",
+      "guardName": "rateLimiter",
+      "guardType": "class",
+      "className": "RateLimiter",
+      "sourceFile": "/project/src/app.module.ts",
+      "annotations": {
+        "celerity.handler.guard.custom": "rateLimiter"
+      },
+      "spec": {
+        "handlerName": "RateLimiter-check",
+        "codeLocation": "./src",
+        "handler": "app.module.RateLimiter.check"
+      }
+    }
+  ],
   "dependencyGraph": {
-    "nodes": []
+    "nodes": [
+      {
+        "token": "OrderService",
+        "tokenType": "class",
+        "providerType": "class",
+        "dependencies": ["celerity:datastore:default"]
+      }
+    ]
   }
 }
 ```
 
 ## Annotation Types
 
+### HTTP
+
 | Annotation | Source |
 |---|---|
-| `celerity.handler.http` | `@Get`, `@Post`, etc. |
+| `celerity.handler.http` | `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete` |
 | `celerity.handler.http.method` | HTTP method from decorator |
-| `celerity.handler.http.path` | Full path (prefix + route) |
+| `celerity.handler.http.path` | Full path (controller prefix + route) |
+
+### WebSocket
+
+| Annotation | Source |
+|---|---|
+| `celerity.handler.websocket` | `@OnConnect`, `@OnDisconnect`, `@OnMessage` |
+| `celerity.handler.websocket.route` | WebSocket route key |
+| `celerity.handler.websocket.eventType` | `connect`, `disconnect`, or `message` |
+
+### Consumer
+
+| Annotation | Source |
+|---|---|
+| `celerity.handler.consumer` | `@ConsumerHandler` |
+| `celerity.handler.consumer.source` | Blueprint resource name from `@Consumer` controller |
+| `celerity.handler.consumer.route` | Message routing pattern |
+
+### Schedule
+
+| Annotation | Source |
+|---|---|
+| `celerity.handler.schedule` | `@ScheduleHandler` |
+| `celerity.handler.schedule.source` | Blueprint resource name from `@ScheduleHandler` |
+| `celerity.handler.schedule.expression` | Cron or rate expression |
+
+### Custom (Invoke)
+
+| Annotation | Source |
+|---|---|
+| `celerity.handler.custom` | `@Invoke` |
+| `celerity.handler.custom.name` | Invocation name |
+
+### Guards
+
+| Annotation | Source |
+|---|---|
 | `celerity.handler.guard.protectedBy` | `@ProtectedBy(...)` |
-| `celerity.handler.guard.custom` | `@Guard(name)` |
+| `celerity.handler.guard.custom` | `@Guard(name)` or `defineGuard` |
 | `celerity.handler.public` | `@Public()` |
+
+### Shared
+
+| Annotation | Source |
+|---|---|
 | `celerity.handler.metadata.*` | `@SetMetadata(key, value)`, `@Action(name)` |
+| `celerity.handler.resource.ref` | `@Bucket`, `@Queue`, `@Topic`, etc. |
 
 ## Part of the Celerity Framework
 

package/dist/extract/cli.cjs

@@ -31,6 +31,7 @@ var import_debug2 = __toESM(require("debug"), 1);
 // src/extract/metadata-app.ts
 var import_reflect_metadata = require("reflect-metadata");
 var import_debug = __toESM(require("debug"), 1);
+var import_common = require("@celerity-sdk/common");
 var import_core = require("@celerity-sdk/core");
 var debug = (0, import_debug.default)("celerity:cli");
 function scanProvider(provider, seenTokens) {
@@ -57,10 +58,12 @@ function buildScannedModule(rootModule) {
   const graph = (0, import_core.buildModuleGraph)(rootModule);
   const controllerClasses = [];
   const functionHandlers = [];
+  const guardClasses = [];
+  const functionGuards = [];
   const providers = [];
   const seenTokens = /* @__PURE__ */ new Set();
   for (const [moduleClass, node] of graph) {
-    debug("scan: module %s \u2014 %d providers, %d controllers", moduleClass.name, node.providers.length, node.controllers.length);
+    debug("scan: module %s \u2014 %d providers, %d controllers, %d guards", moduleClass.name, node.providers.length, node.controllers.length, node.guards.length);
     for (const provider of node.providers) {
       const scanned = scanProvider(provider, seenTokens);
       if (scanned) providers.push(scanned);
@@ -76,11 +79,28 @@ function buildScannedModule(rootModule) {
         });
       }
     }
+    for (const guard of node.guards) {
+      if (typeof guard === "function") {
+        guardClasses.push(guard);
+        if (!seenTokens.has(guard)) {
+          seenTokens.add(guard);
+          providers.push({
+            token: guard,
+            providerType: "class",
+            dependencies: (0, import_core.getClassDependencyTokens)(guard)
+          });
+        }
+      } else {
+        functionGuards.push(guard);
+      }
+    }
     functionHandlers.push(...node.functionHandlers);
   }
   return {
     controllerClasses,
     functionHandlers,
+    guardClasses,
+    functionGuards,
     providers
   };
 }
@@ -100,7 +120,7 @@ function validateScannedDependencies(scanned) {
         }
       } else if (typeof dep === "function") {
         walk(dep, (0, import_core.getClassDependencyTokens)(dep));
-      } else {
+      } else if (!(0, import_common.isResourceLayerToken)(dep)) {
         diagnostics.push({
           consumer: serializeToken(token),
           dependency: serializeToken(dep)
@@ -127,7 +147,7 @@ var import_reflect_metadata2 = require("reflect-metadata");
 var import_core2 = require("@celerity-sdk/core");
 
 // src/extract/path-utils.ts
-var import_common = require("@celerity-sdk/common");
+var import_common2 = require("@celerity-sdk/common");
 
 // src/extract/identity.ts
 var import_node_path = require("path");
@@ -165,8 +185,9 @@ __name(deriveCodeLocation, "deriveCodeLocation");
 function serializeManifest(scanned, sourceFile, options) {
   const handlers = [];
   const functionHandlers = [];
+  const guardHandlers = [];
   for (const controllerClass of scanned.controllerClasses) {
-    const entries = serializeClassHandler(controllerClass, sourceFile, options);
+    const entries = serializeClassHandlers(controllerClass, sourceFile, options);
     handlers.push(...entries);
   }
   for (const fnHandler of scanned.functionHandlers) {
@@ -175,40 +196,76 @@ function serializeManifest(scanned, sourceFile, options) {
       functionHandlers.push(entry);
     }
   }
+  for (const guardClass of scanned.guardClasses) {
+    const entry = serializeClassGuard(guardClass, sourceFile, options);
+    if (entry) {
+      guardHandlers.push(entry);
+    }
+  }
+  for (const fnGuard of scanned.functionGuards) {
+    const entry = serializeFunctionGuard(fnGuard, sourceFile, options);
+    if (entry) {
+      guardHandlers.push(entry);
+    }
+  }
   return {
     version: "1.0.0",
     handlers,
     functionHandlers,
+    guardHandlers,
     dependencyGraph: serializeDependencyGraph(scanned)
   };
 }
 __name(serializeManifest, "serializeManifest");
-function extractClassMeta(controllerClass) {
-  const controllerMeta = Reflect.getOwnMetadata(import_core2.CONTROLLER_METADATA, controllerClass);
-  if (!controllerMeta) return null;
+function extractControllerMeta(controllerClass) {
+  const httpMeta = Reflect.getOwnMetadata(import_core2.CONTROLLER_METADATA, controllerClass);
+  if (httpMeta) {
+    return {
+      controllerType: "http",
+      prefix: httpMeta.prefix ?? "",
+      ...extractSharedClassMeta(controllerClass)
+    };
+  }
+  const isWebSocket = Reflect.getOwnMetadata(import_core2.WEBSOCKET_CONTROLLER_METADATA, controllerClass);
+  if (isWebSocket) {
+    return {
+      controllerType: "websocket",
+      prefix: "",
+      ...extractSharedClassMeta(controllerClass)
+    };
+  }
+  const consumerMeta = Reflect.getOwnMetadata(import_core2.CONSUMER_METADATA, controllerClass);
+  if (consumerMeta) {
+    return {
+      controllerType: "consumer",
+      prefix: "",
+      source: consumerMeta.source,
+      ...extractSharedClassMeta(controllerClass)
+    };
+  }
+  return null;
+}
+__name(extractControllerMeta, "extractControllerMeta");
+function extractSharedClassMeta(controllerClass) {
   return {
-    prefix: controllerMeta.prefix ?? "",
     protectedBy: Reflect.getOwnMetadata(import_core2.GUARD_PROTECTEDBY_METADATA, controllerClass) ?? [],
     customGuardName: Reflect.getOwnMetadata(import_core2.GUARD_CUSTOM_METADATA, controllerClass),
-    customMetadata: Reflect.getOwnMetadata(import_core2.CUSTOM_METADATA, controllerClass) ?? {}
+    customMetadata: Reflect.getOwnMetadata(import_core2.CUSTOM_METADATA, controllerClass) ?? {},
+    resourceRefs: Reflect.getOwnMetadata(import_core2.USE_RESOURCE_METADATA, controllerClass) ?? []
   };
 }
-__name(extractClassMeta, "extractClassMeta");
-function buildMethodAnnotations(classMeta, prototype, methodName, httpMethod, fullPath) {
-  const annotations = {};
-  annotations["celerity.handler.http"] = true;
-  annotations["celerity.handler.http.method"] = httpMethod;
-  annotations["celerity.handler.http.path"] = fullPath;
+__name(extractSharedClassMeta, "extractSharedClassMeta");
+function appendSharedAnnotations(annotations, meta, prototype, methodName) {
   const methodProtectedBy = Reflect.getOwnMetadata(import_core2.GUARD_PROTECTEDBY_METADATA, prototype, methodName) ?? [];
   const allProtectedBy = [
-    ...classMeta.protectedBy,
+    ...meta.protectedBy,
     ...methodProtectedBy
   ];
   if (allProtectedBy.length > 0) {
     annotations["celerity.handler.guard.protectedBy"] = allProtectedBy;
   }
-  if (classMeta.customGuardName) {
-    annotations["celerity.handler.guard.custom"] = classMeta.customGuardName;
+  if (meta.customGuardName) {
+    annotations["celerity.handler.guard.custom"] = meta.customGuardName;
   }
   const isPublic = Reflect.getOwnMetadata(import_core2.PUBLIC_METADATA, prototype, methodName) === true;
   if (isPublic) {
@@ -216,57 +273,206 @@ function buildMethodAnnotations(classMeta, prototype, methodName, httpMethod, fu
   }
   const methodCustomMetadata = Reflect.getOwnMetadata(import_core2.CUSTOM_METADATA, prototype, methodName) ?? {};
   const customMetadata = {
-    ...classMeta.customMetadata,
+    ...meta.customMetadata,
     ...methodCustomMetadata
   };
   for (const [key, value] of Object.entries(customMetadata)) {
     if (value === void 0) continue;
     annotations[`celerity.handler.metadata.${key}`] = serializeAnnotationValue(value);
   }
+  const methodResourceRefs = Reflect.getOwnMetadata(import_core2.USE_RESOURCE_METADATA, prototype, methodName) ?? [];
+  const allResourceRefs = [
+    .../* @__PURE__ */ new Set([
+      ...meta.resourceRefs,
+      ...methodResourceRefs
+    ])
+  ];
+  if (allResourceRefs.length > 0) {
+    annotations["celerity.handler.resource.ref"] = allResourceRefs;
+  }
+}
+__name(appendSharedAnnotations, "appendSharedAnnotations");
+function buildHttpAnnotations(meta, prototype, methodName, httpMethod, fullPath) {
+  const annotations = {};
+  annotations["celerity.handler.http"] = true;
+  annotations["celerity.handler.http.method"] = httpMethod;
+  annotations["celerity.handler.http.path"] = fullPath;
+  appendSharedAnnotations(annotations, meta, prototype, methodName);
+  return annotations;
+}
+__name(buildHttpAnnotations, "buildHttpAnnotations");
+function buildWebSocketAnnotations(meta, prototype, methodName, wsEvent) {
+  const annotations = {};
+  annotations["celerity.handler.websocket"] = true;
+  annotations["celerity.handler.websocket.route"] = wsEvent.route;
+  annotations["celerity.handler.websocket.eventType"] = wsEvent.eventType;
+  appendSharedAnnotations(annotations, meta, prototype, methodName);
+  return annotations;
+}
+__name(buildWebSocketAnnotations, "buildWebSocketAnnotations");
+function buildConsumerAnnotations(meta, prototype, methodName, consumerHandler) {
+  const annotations = {};
+  annotations["celerity.handler.consumer"] = true;
+  if (meta.source) {
+    annotations["celerity.handler.consumer.source"] = meta.source;
+  }
+  if (consumerHandler.route) {
+    annotations["celerity.handler.consumer.route"] = consumerHandler.route;
+  }
+  appendSharedAnnotations(annotations, meta, prototype, methodName);
+  return annotations;
+}
+__name(buildConsumerAnnotations, "buildConsumerAnnotations");
+function buildScheduleAnnotations(meta, prototype, methodName, scheduleMeta) {
+  const annotations = {};
+  annotations["celerity.handler.schedule"] = true;
+  if (scheduleMeta.source) {
+    annotations["celerity.handler.schedule.source"] = scheduleMeta.source;
+  }
+  if (scheduleMeta.schedule) {
+    annotations["celerity.handler.schedule.expression"] = scheduleMeta.schedule;
+  }
+  appendSharedAnnotations(annotations, meta, prototype, methodName);
   return annotations;
 }
-__name(buildMethodAnnotations, "buildMethodAnnotations");
-function serializeClassHandler(controllerClass, sourceFile, options) {
-  const classMeta = extractClassMeta(controllerClass);
-  if (!classMeta) return [];
+__name(buildScheduleAnnotations, "buildScheduleAnnotations");
+function buildCustomAnnotations(meta, prototype, methodName, invokeMeta) {
+  const annotations = {};
+  annotations["celerity.handler.custom"] = true;
+  annotations["celerity.handler.custom.name"] = invokeMeta.name;
+  appendSharedAnnotations(annotations, meta, prototype, methodName);
+  return annotations;
+}
+__name(buildCustomAnnotations, "buildCustomAnnotations");
+function serializeClassHandlers(controllerClass, sourceFile, options) {
+  const meta = extractControllerMeta(controllerClass);
+  if (!meta) return [];
   const className = controllerClass.name;
   const prototype = controllerClass.prototype;
   const methods = Object.getOwnPropertyNames(prototype).filter((n) => n !== "constructor");
   const entries = [];
   for (const methodName of methods) {
-    const httpMethod = Reflect.getOwnMetadata(import_core2.HTTP_METHOD_METADATA, prototype, methodName);
-    if (!httpMethod) continue;
-    const routePath = Reflect.getOwnMetadata(import_core2.ROUTE_PATH_METADATA, prototype, methodName) ?? "/";
-    const fullPath = (0, import_common.joinHandlerPath)(classMeta.prefix, routePath);
-    const annotations = buildMethodAnnotations(classMeta, prototype, methodName, httpMethod, fullPath);
-    entries.push({
-      resourceName: deriveClassResourceName(className, methodName),
-      className,
-      methodName,
-      sourceFile,
-      handlerType: "http",
-      annotations,
-      spec: {
-        handlerName: deriveClassHandlerName(className, methodName),
-        codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
-        handler: deriveClassHandlerFunction(sourceFile, className, methodName)
-      }
-    });
+    const typeEntry = serializeControllerTypeMethod(meta, className, prototype, methodName, sourceFile, options);
+    if (typeEntry) entries.push(typeEntry);
+    const scheduleMeta = Reflect.getOwnMetadata(import_core2.SCHEDULE_HANDLER_METADATA, prototype, methodName);
+    if (scheduleMeta) {
+      entries.push({
+        resourceName: deriveClassResourceName(className, methodName),
+        className,
+        methodName,
+        sourceFile,
+        handlerType: "schedule",
+        annotations: buildScheduleAnnotations(meta, prototype, methodName, scheduleMeta),
+        spec: {
+          handlerName: deriveClassHandlerName(className, methodName),
+          codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+          handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+        }
+      });
+    }
+    const invokeMeta = Reflect.getOwnMetadata(import_core2.INVOKE_METADATA, prototype, methodName);
+    if (invokeMeta) {
+      entries.push({
+        resourceName: deriveClassResourceName(className, methodName),
+        className,
+        methodName,
+        sourceFile,
+        handlerType: "custom",
+        annotations: buildCustomAnnotations(meta, prototype, methodName, invokeMeta),
+        spec: {
+          handlerName: deriveClassHandlerName(className, methodName),
+          codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+          handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+        }
+      });
+    }
   }
   return entries;
 }
-__name(serializeClassHandler, "serializeClassHandler");
+__name(serializeClassHandlers, "serializeClassHandlers");
+function serializeControllerTypeMethod(meta, className, prototype, methodName, sourceFile, options) {
+  switch (meta.controllerType) {
+    case "http":
+      return serializeHttpMethod(meta, className, prototype, methodName, sourceFile, options);
+    case "websocket":
+      return serializeWebSocketMethod(meta, className, prototype, methodName, sourceFile, options);
+    case "consumer":
+      return serializeConsumerMethod(meta, className, prototype, methodName, sourceFile, options);
+    default:
+      return null;
+  }
+}
+__name(serializeControllerTypeMethod, "serializeControllerTypeMethod");
+function serializeHttpMethod(meta, className, prototype, methodName, sourceFile, options) {
+  const httpMethod = Reflect.getOwnMetadata(import_core2.HTTP_METHOD_METADATA, prototype, methodName);
+  if (!httpMethod) return null;
+  const routePath = Reflect.getOwnMetadata(import_core2.ROUTE_PATH_METADATA, prototype, methodName) ?? "/";
+  const fullPath = (0, import_common2.joinHandlerPath)(meta.prefix, routePath);
+  return {
+    resourceName: deriveClassResourceName(className, methodName),
+    className,
+    methodName,
+    sourceFile,
+    handlerType: "http",
+    annotations: buildHttpAnnotations(meta, prototype, methodName, httpMethod, fullPath),
+    spec: {
+      handlerName: deriveClassHandlerName(className, methodName),
+      codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+      handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+    }
+  };
+}
+__name(serializeHttpMethod, "serializeHttpMethod");
+function serializeWebSocketMethod(meta, className, prototype, methodName, sourceFile, options) {
+  const wsEvent = Reflect.getOwnMetadata(import_core2.WEBSOCKET_EVENT_METADATA, prototype, methodName);
+  if (!wsEvent) return null;
+  return {
+    resourceName: deriveClassResourceName(className, methodName),
+    className,
+    methodName,
+    sourceFile,
+    handlerType: "websocket",
+    annotations: buildWebSocketAnnotations(meta, prototype, methodName, wsEvent),
+    spec: {
+      handlerName: deriveClassHandlerName(className, methodName),
+      codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+      handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+    }
+  };
+}
+__name(serializeWebSocketMethod, "serializeWebSocketMethod");
+function serializeConsumerMethod(meta, className, prototype, methodName, sourceFile, options) {
+  const consumerHandler = Reflect.getOwnMetadata(import_core2.CONSUMER_HANDLER_METADATA, prototype, methodName);
+  if (!consumerHandler) return null;
+  return {
+    resourceName: deriveClassResourceName(className, methodName),
+    className,
+    methodName,
+    sourceFile,
+    handlerType: "consumer",
+    annotations: buildConsumerAnnotations(meta, prototype, methodName, consumerHandler),
+    spec: {
+      handlerName: deriveClassHandlerName(className, methodName),
+      codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+      handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+    }
+  };
+}
+__name(serializeConsumerMethod, "serializeConsumerMethod");
 function serializeFunctionHandler(definition, sourceFile, options) {
+  const supported = [
+    "http",
+    "websocket",
+    "consumer",
+    "schedule",
+    "custom"
+  ];
+  if (!supported.includes(definition.type)) return null;
   const exportName = definition.metadata.handlerName ?? "handler";
   const customMetadata = definition.metadata.customMetadata ?? {};
+  const handlerType = definition.type;
   const annotations = {};
-  const path = definition.metadata.path;
-  const method = definition.metadata.method;
-  if (path !== void 0 && method !== void 0) {
-    annotations["celerity.handler.http"] = true;
-    annotations["celerity.handler.http.method"] = method;
-    annotations["celerity.handler.http.path"] = path;
-  }
+  buildFunctionTypeAnnotations(annotations, definition);
   for (const [key, value] of Object.entries(customMetadata)) {
     if (value === void 0) continue;
     annotations[`celerity.handler.metadata.${key}`] = serializeAnnotationValue(value);
@@ -275,6 +481,7 @@ function serializeFunctionHandler(definition, sourceFile, options) {
     resourceName: deriveFunctionResourceName(exportName),
     exportName,
     sourceFile,
+    handlerType,
     ...Object.keys(annotations).length > 0 ? {
       annotations
     } : {},
@@ -286,6 +493,122 @@ function serializeFunctionHandler(definition, sourceFile, options) {
   };
 }
 __name(serializeFunctionHandler, "serializeFunctionHandler");
+function buildFunctionTypeAnnotations(annotations, definition) {
+  const meta = definition.metadata;
+  switch (definition.type) {
+    case "http": {
+      const path = meta.path;
+      const method = meta.method;
+      if (path !== void 0 && method !== void 0) {
+        annotations["celerity.handler.http"] = true;
+        annotations["celerity.handler.http.method"] = method;
+        annotations["celerity.handler.http.path"] = path;
+      }
+      break;
+    }
+    case "websocket": {
+      annotations["celerity.handler.websocket"] = true;
+      const route = meta.route;
+      if (route) {
+        annotations["celerity.handler.websocket.route"] = route;
+      }
+      break;
+    }
+    case "consumer": {
+      annotations["celerity.handler.consumer"] = true;
+      const route = meta.route;
+      if (route) {
+        annotations["celerity.handler.consumer.route"] = route;
+      }
+      break;
+    }
+    case "schedule": {
+      annotations["celerity.handler.schedule"] = true;
+      const source = meta.source;
+      if (source) {
+        annotations["celerity.handler.schedule.source"] = source;
+      }
+      const schedule = meta.schedule;
+      if (schedule) {
+        annotations["celerity.handler.schedule.expression"] = schedule;
+      }
+      break;
+    }
+    case "custom": {
+      annotations["celerity.handler.custom"] = true;
+      const name = meta.name;
+      if (name) {
+        annotations["celerity.handler.custom.name"] = name;
+      }
+      break;
+    }
+  }
+}
+__name(buildFunctionTypeAnnotations, "buildFunctionTypeAnnotations");
+function extractGuardMeta(guardClass) {
+  const guardName = Reflect.getOwnMetadata(import_core2.GUARD_CUSTOM_METADATA, guardClass);
+  if (!guardName) return null;
+  return {
+    guardName,
+    customMetadata: Reflect.getOwnMetadata(import_core2.CUSTOM_METADATA, guardClass) ?? {}
+  };
+}
+__name(extractGuardMeta, "extractGuardMeta");
+function serializeClassGuard(guardClass, sourceFile, options) {
+  const meta = extractGuardMeta(guardClass);
+  if (!meta) return null;
+  const className = guardClass.name;
+  const methodName = "check";
+  const annotations = {
+    "celerity.handler.guard.custom": meta.guardName
+  };
+  for (const [key, value] of Object.entries(meta.customMetadata)) {
+    if (value === void 0) continue;
+    annotations[`celerity.handler.metadata.${key}`] = serializeAnnotationValue(value);
+  }
+  return {
+    resourceName: deriveClassResourceName(className, methodName),
+    guardName: meta.guardName,
+    sourceFile,
+    guardType: "class",
+    className,
+    annotations,
+    spec: {
+      handlerName: deriveClassHandlerName(className, methodName),
+      codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+      handler: deriveClassHandlerFunction(sourceFile, className, methodName)
+    }
+  };
+}
+__name(serializeClassGuard, "serializeClassGuard");
+function serializeFunctionGuard(definition, sourceFile, options) {
+  const guardName = definition.name;
+  if (!guardName) return null;
+  const meta = definition.metadata ?? {};
+  const customMetadata = meta.customMetadata ?? {};
+  const annotations = {
+    "celerity.handler.guard.custom": guardName
+  };
+  for (const [key, value] of Object.entries(customMetadata)) {
+    if (value === void 0) continue;
+    annotations[`celerity.handler.metadata.${key}`] = serializeAnnotationValue(value);
+  }
+  const exportName = guardName;
+  return {
+    resourceName: deriveFunctionResourceName(exportName),
+    guardName,
+    sourceFile,
+    guardType: "function",
+    exportName,
+    annotations,
+    spec: {
+      handlerName: exportName,
+      codeLocation: deriveCodeLocation(sourceFile, options.projectRoot),
+      handler: deriveFunctionHandlerFunction(sourceFile, exportName)
+    }
+  };
+}
+__name(serializeFunctionGuard, "serializeFunctionGuard");
 function serializeAnnotationValue(value) {
   if (typeof value === "boolean") return value;
   if (typeof value === "string") return value;