@celerity-sdk/core 0.2.0

package/dist/index.js

@@ -0,0 +1,1885 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import "reflect-metadata";
+
+// src/decorators/controller.ts
+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");
+
+// src/decorators/controller.ts
+function Controller(prefix) {
+  return (target) => {
+    const metadata = {};
+    if (prefix !== void 0) {
+      metadata.prefix = prefix;
+    }
+    Reflect.defineMetadata(CONTROLLER_METADATA, metadata, target);
+    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+  };
+}
+__name(Controller, "Controller");
+
+// src/decorators/http.ts
+import "reflect-metadata";
+function createMethodDecorator(method, path = "/") {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(HTTP_METHOD_METADATA, method, target, propertyKey);
+    Reflect.defineMetadata(ROUTE_PATH_METADATA, path, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(createMethodDecorator, "createMethodDecorator");
+function Get(path) {
+  return createMethodDecorator("GET", path);
+}
+__name(Get, "Get");
+function Post(path) {
+  return createMethodDecorator("POST", path);
+}
+__name(Post, "Post");
+function Put(path) {
+  return createMethodDecorator("PUT", path);
+}
+__name(Put, "Put");
+function Patch(path) {
+  return createMethodDecorator("PATCH", path);
+}
+__name(Patch, "Patch");
+function Delete(path) {
+  return createMethodDecorator("DELETE", path);
+}
+__name(Delete, "Delete");
+function Head(path) {
+  return createMethodDecorator("HEAD", path);
+}
+__name(Head, "Head");
+function Options(path) {
+  return createMethodDecorator("OPTIONS", path);
+}
+__name(Options, "Options");
+
+// src/decorators/params.ts
+import "reflect-metadata";
+function createParamDecorator(type, keyOrSchema, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) return;
+    const existing = Reflect.getOwnMetadata(PARAM_METADATA, target, propertyKey) ?? [];
+    const meta = {
+      index: parameterIndex,
+      type
+    };
+    if (typeof keyOrSchema === "string") {
+      meta.key = keyOrSchema;
+      if (schema) meta.schema = schema;
+    } else if (keyOrSchema && typeof keyOrSchema === "object") {
+      meta.schema = keyOrSchema;
+    }
+    existing.push(meta);
+    Reflect.defineMetadata(PARAM_METADATA, existing, target, propertyKey);
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+function Body(schema) {
+  return createParamDecorator("body", schema);
+}
+__name(Body, "Body");
+function Query(keyOrSchema, schema) {
+  return createParamDecorator("query", keyOrSchema, schema);
+}
+__name(Query, "Query");
+function Param(keyOrSchema, schema) {
+  return createParamDecorator("param", keyOrSchema, schema);
+}
+__name(Param, "Param");
+function Headers(keyOrSchema, schema) {
+  return createParamDecorator("headers", keyOrSchema, schema);
+}
+__name(Headers, "Headers");
+function Auth() {
+  return createParamDecorator("auth");
+}
+__name(Auth, "Auth");
+function Req() {
+  return createParamDecorator("request");
+}
+__name(Req, "Req");
+function Cookies(key) {
+  return createParamDecorator("cookies", key);
+}
+__name(Cookies, "Cookies");
+function RequestId() {
+  return createParamDecorator("requestId");
+}
+__name(RequestId, "RequestId");
+function extractParam(type, key, request) {
+  switch (type) {
+    case "body":
+      return request.textBody ? JSON.parse(request.textBody) : null;
+    case "query":
+      return key ? request.query[key] : request.query;
+    case "param":
+      return key ? request.pathParams[key] : request.pathParams;
+    case "headers":
+      return key ? request.headers[key] : request.headers;
+    case "auth":
+      return request.auth;
+    case "request":
+      return request;
+    case "cookies":
+      return key ? request.cookies[key] : request.cookies;
+    case "requestId":
+      return request.requestId;
+  }
+}
+__name(extractParam, "extractParam");
+
+// src/decorators/guards.ts
+import "reflect-metadata";
+function Guard(name) {
+  return (target) => {
+    Reflect.defineMetadata(GUARD_CUSTOM_METADATA, name, target);
+  };
+}
+__name(Guard, "Guard");
+function ProtectedBy(name) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, target, propertyKey) ?? [];
+      Reflect.defineMetadata(GUARD_PROTECTEDBY_METADATA, [
+        name,
+        ...existing
+      ], target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(GUARD_PROTECTEDBY_METADATA, target) ?? [];
+      Reflect.defineMetadata(GUARD_PROTECTEDBY_METADATA, [
+        name,
+        ...existing
+      ], target);
+    }
+  };
+}
+__name(ProtectedBy, "ProtectedBy");
+function Public() {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(PUBLIC_METADATA, true, target, propertyKey);
+    return descriptor;
+  };
+}
+__name(Public, "Public");
+
+// src/decorators/layer.ts
+import "reflect-metadata";
+function UseLayer(...layers) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(LAYER_METADATA, target, propertyKey) ?? [];
+      Reflect.defineMetadata(LAYER_METADATA, [
+        ...layers,
+        ...existing
+      ], target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(LAYER_METADATA, target) ?? [];
+      Reflect.defineMetadata(LAYER_METADATA, [
+        ...layers,
+        ...existing
+      ], target);
+    }
+  };
+}
+__name(UseLayer, "UseLayer");
+function UseLayers(layers) {
+  return UseLayer(...layers);
+}
+__name(UseLayers, "UseLayers");
+
+// src/decorators/metadata.ts
+import "reflect-metadata";
+function SetMetadata(key, value) {
+  return (target, propertyKey, _descriptor) => {
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(CUSTOM_METADATA, target, propertyKey) ?? {};
+      Reflect.defineMetadata(CUSTOM_METADATA, {
+        ...existing,
+        [key]: value
+      }, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(CUSTOM_METADATA, target) ?? {};
+      Reflect.defineMetadata(CUSTOM_METADATA, {
+        ...existing,
+        [key]: value
+      }, target);
+    }
+  };
+}
+__name(SetMetadata, "SetMetadata");
+function Action(value) {
+  return SetMetadata("action", value);
+}
+__name(Action, "Action");
+
+// src/decorators/injectable.ts
+import "reflect-metadata";
+function Injectable() {
+  return (target) => {
+    Reflect.defineMetadata(INJECTABLE_METADATA, true, target);
+  };
+}
+__name(Injectable, "Injectable");
+function Inject(token) {
+  return (target, _propertyKey, parameterIndex) => {
+    const existing = Reflect.getOwnMetadata(INJECT_METADATA, target) ?? /* @__PURE__ */ new Map();
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(INJECT_METADATA, existing, target);
+  };
+}
+__name(Inject, "Inject");
+
+// src/decorators/module.ts
+import "reflect-metadata";
+function Module(metadata) {
+  return (target) => {
+    Reflect.defineMetadata(MODULE_METADATA, metadata, target);
+  };
+}
+__name(Module, "Module");
+
+// src/errors/http-exception.ts
+var HttpException = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  statusCode;
+  details;
+  constructor(statusCode, message, details) {
+    super(message), this.statusCode = statusCode, this.details = details;
+    this.name = "HttpException";
+  }
+};
+var BadRequestException = class extends HttpException {
+  static {
+    __name(this, "BadRequestException");
+  }
+  constructor(message = "Bad Request", details) {
+    super(400, message, details);
+    this.name = "BadRequestException";
+  }
+};
+var UnauthorizedException = class extends HttpException {
+  static {
+    __name(this, "UnauthorizedException");
+  }
+  constructor(message = "Unauthorized", details) {
+    super(401, message, details);
+    this.name = "UnauthorizedException";
+  }
+};
+var ForbiddenException = class extends HttpException {
+  static {
+    __name(this, "ForbiddenException");
+  }
+  constructor(message = "Forbidden", details) {
+    super(403, message, details);
+    this.name = "ForbiddenException";
+  }
+};
+var NotFoundException = class extends HttpException {
+  static {
+    __name(this, "NotFoundException");
+  }
+  constructor(message = "Not Found", details) {
+    super(404, message, details);
+    this.name = "NotFoundException";
+  }
+};
+var MethodNotAllowedException = class extends HttpException {
+  static {
+    __name(this, "MethodNotAllowedException");
+  }
+  constructor(message = "Method Not Allowed", details) {
+    super(405, message, details);
+    this.name = "MethodNotAllowedException";
+  }
+};
+var NotAcceptableException = class extends HttpException {
+  static {
+    __name(this, "NotAcceptableException");
+  }
+  constructor(message = "Not Acceptable", details) {
+    super(406, message, details);
+    this.name = "NotAcceptableException";
+  }
+};
+var ConflictException = class extends HttpException {
+  static {
+    __name(this, "ConflictException");
+  }
+  constructor(message = "Conflict", details) {
+    super(409, message, details);
+    this.name = "ConflictException";
+  }
+};
+var GoneException = class extends HttpException {
+  static {
+    __name(this, "GoneException");
+  }
+  constructor(message = "Gone", details) {
+    super(410, message, details);
+    this.name = "GoneException";
+  }
+};
+var UnprocessableEntityException = class extends HttpException {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
+  constructor(message = "Unprocessable Entity", details) {
+    super(422, message, details);
+    this.name = "UnprocessableEntityException";
+  }
+};
+var TooManyRequestsException = class extends HttpException {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  constructor(message = "Too Many Requests", details) {
+    super(429, message, details);
+    this.name = "TooManyRequestsException";
+  }
+};
+var InternalServerErrorException = class extends HttpException {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
+  constructor(message = "Internal Server Error", details) {
+    super(500, message, details);
+    this.name = "InternalServerErrorException";
+  }
+};
+var NotImplementedException = class extends HttpException {
+  static {
+    __name(this, "NotImplementedException");
+  }
+  constructor(message = "Not Implemented", details) {
+    super(501, message, details);
+    this.name = "NotImplementedException";
+  }
+};
+var BadGatewayException = class extends HttpException {
+  static {
+    __name(this, "BadGatewayException");
+  }
+  constructor(message = "Bad Gateway", details) {
+    super(502, message, details);
+    this.name = "BadGatewayException";
+  }
+};
+var ServiceUnavailableException = class extends HttpException {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
+  constructor(message = "Service Unavailable", details) {
+    super(503, message, details);
+    this.name = "ServiceUnavailableException";
+  }
+};
+var GatewayTimeoutException = class extends HttpException {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
+  constructor(message = "Gateway Timeout", details) {
+    super(504, message, details);
+    this.name = "GatewayTimeoutException";
+  }
+};
+
+// src/layers/validate.ts
+var ValidationLayer = class ValidationLayer2 {
+  static {
+    __name(this, "ValidationLayer");
+  }
+  schemas;
+  constructor(schemas) {
+    this.schemas = schemas;
+  }
+  async handle(context, next) {
+    const { request } = context;
+    if (this.schemas.body && request.textBody) {
+      try {
+        const raw = JSON.parse(request.textBody);
+        context.metadata.set("validatedBody", this.schemas.body.parse(raw));
+      } catch (error) {
+        throw new BadRequestException("Body validation failed", formatError(error));
+      }
+    }
+    if (this.schemas.params) {
+      try {
+        context.metadata.set("validatedParams", this.schemas.params.parse(request.pathParams));
+      } catch (error) {
+        throw new BadRequestException("Path params validation failed", formatError(error));
+      }
+    }
+    if (this.schemas.query) {
+      try {
+        context.metadata.set("validatedQuery", this.schemas.query.parse(request.query));
+      } catch (error) {
+        throw new BadRequestException("Query validation failed", formatError(error));
+      }
+    }
+    if (this.schemas.headers) {
+      try {
+        context.metadata.set("validatedHeaders", this.schemas.headers.parse(request.headers));
+      } catch (error) {
+        throw new BadRequestException("Headers validation failed", formatError(error));
+      }
+    }
+    return next();
+  }
+};
+function formatError(error) {
+  if (error instanceof Error && "issues" in error) {
+    return error.issues;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return error;
+}
+__name(formatError, "formatError");
+function validate(schemas) {
+  return new ValidationLayer(schemas);
+}
+__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);
+  let index = -1;
+  function dispatch(i) {
+    if (i <= index) {
+      return Promise.reject(new Error("next() called multiple times"));
+    }
+    index = i;
+    if (i >= resolved.length) {
+      return handler();
+    }
+    const current = resolved[i];
+    debug("layer[%d] %s", i, current.constructor.name);
+    return current.handle(context, () => dispatch(i + 1));
+  }
+  __name(dispatch, "dispatch");
+  return dispatch(0);
+}
+__name(runLayerPipeline, "runLayerPipeline");
+
+// src/layers/system.ts
+import { ConfigLayer } from "@celerity-sdk/config";
+async function createDefaultSystemLayers() {
+  const layers = [];
+  try {
+    const pkg = "@celerity-sdk/telemetry";
+    const mod = await import(pkg);
+    const TelemetryLayerClass = mod.TelemetryLayer;
+    layers.push(new TelemetryLayerClass());
+  } catch {
+  }
+  layers.push(new ConfigLayer());
+  return layers;
+}
+__name(createDefaultSystemLayers, "createDefaultSystemLayers");
+
+// src/layers/dispose.ts
+async function disposeLayers(layers) {
+  for (const layer of [
+    ...layers
+  ].reverse()) {
+    if (typeof layer === "object" && "dispose" in layer) {
+      try {
+        await layer.dispose?.();
+      } catch {
+      }
+    }
+  }
+}
+__name(disposeLayers, "disposeLayers");
+
+// src/metadata/handler-metadata.ts
+var HandlerMetadataStore = class {
+  static {
+    __name(this, "HandlerMetadataStore");
+  }
+  decoratorData;
+  requestData = /* @__PURE__ */ new Map();
+  constructor(decoratorMetadata) {
+    this.decoratorData = new Map(Object.entries(decoratorMetadata));
+  }
+  get(key) {
+    if (this.requestData.has(key)) return this.requestData.get(key);
+    return this.decoratorData.get(key);
+  }
+  set(key, value) {
+    this.requestData.set(key, value);
+  }
+  has(key) {
+    return this.requestData.has(key) || this.decoratorData.has(key);
+  }
+};
+
+// src/di/container.ts
+import "reflect-metadata";
+import createDebug2 from "debug";
+
+// src/di/dependency-tokens.ts
+import "reflect-metadata";
+function isClassProvider(p) {
+  return "useClass" in p;
+}
+__name(isClassProvider, "isClassProvider");
+function isFactoryProvider(p) {
+  return "useFactory" in p;
+}
+__name(isFactoryProvider, "isFactoryProvider");
+function getClassDependencyTokens(target) {
+  const paramTypes = Reflect.getMetadata("design:paramtypes", target) ?? [];
+  const injectOverrides = Reflect.getMetadata(INJECT_METADATA, target) ?? /* @__PURE__ */ new Map();
+  return paramTypes.map((paramType, index) => injectOverrides.get(index) ?? paramType);
+}
+__name(getClassDependencyTokens, "getClassDependencyTokens");
+function getProviderDependencyTokens(provider) {
+  if (isClassProvider(provider)) {
+    return getClassDependencyTokens(provider.useClass);
+  }
+  if (isFactoryProvider(provider) && provider.inject) {
+    return [
+      ...provider.inject
+    ];
+  }
+  return [];
+}
+__name(getProviderDependencyTokens, "getProviderDependencyTokens");
+
+// src/di/container.ts
+var debug2 = createDebug2("celerity:core:di");
+var CLOSE_METHODS = [
+  "close",
+  "end",
+  "quit",
+  "disconnect",
+  "$disconnect",
+  "destroy"
+];
+function isClassProvider2(p) {
+  return "useClass" in p;
+}
+__name(isClassProvider2, "isClassProvider");
+function isFactoryProvider2(p) {
+  return "useFactory" in p;
+}
+__name(isFactoryProvider2, "isFactoryProvider");
+function isValueProvider(p) {
+  return "useValue" in p;
+}
+__name(isValueProvider, "isValueProvider");
+function tokenToString(token) {
+  if (typeof token === "function") return token.name;
+  return String(token);
+}
+__name(tokenToString, "tokenToString");
+function detectCloseMethod(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const obj = value;
+  for (const method of CLOSE_METHODS) {
+    if (typeof obj[method] === "function") {
+      return () => obj[method]();
+    }
+  }
+  return null;
+}
+__name(detectCloseMethod, "detectCloseMethod");
+var Container = class {
+  static {
+    __name(this, "Container");
+  }
+  providers = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  edges = /* @__PURE__ */ new Map();
+  closeStack = [];
+  trackedTokens = /* @__PURE__ */ new Set();
+  register(token, provider) {
+    const type = isClassProvider2(provider) ? "class" : isFactoryProvider2(provider) ? "factory" : "value";
+    debug2("register %s (%s)", tokenToString(token), type);
+    this.providers.set(token, provider);
+    if (isValueProvider(provider)) {
+      this.trackCloseable(token, provider.useValue, provider.onClose);
+    }
+  }
+  registerClass(target) {
+    debug2("register %s (class)", target.name);
+    this.providers.set(target, {
+      useClass: target
+    });
+  }
+  registerValue(token, value) {
+    debug2("registerValue %s", tokenToString(token));
+    this.instances.set(token, value);
+    this.trackCloseable(token, value);
+  }
+  async resolve(token) {
+    const name = tokenToString(token);
+    if (this.instances.has(token)) {
+      debug2("resolve %s \u2192 cached", name);
+      return this.instances.get(token);
+    }
+    if (this.resolving.has(token)) {
+      const path = [
+        ...this.resolving,
+        token
+      ].map(tokenToString).join(" \u2192 ");
+      throw new Error(`Circular dependency detected: ${path}`);
+    }
+    debug2("resolve %s \u2192 constructing", name);
+    this.resolving.add(token);
+    try {
+      const provider = this.providers.get(token);
+      if (!provider) {
+        if (typeof token === "function") {
+          return this.constructClass(token);
+        }
+        throw new Error(`No provider registered for ${tokenToString(token)}.
+Ensure the module providing it is included in your module's "imports" array,
+or register a provider for it directly.`);
+      }
+      if (isFactoryProvider2(provider) && provider.inject) {
+        this.recordEdges(token, provider.inject);
+      }
+      const instance = await this.createFromProvider(provider);
+      this.instances.set(token, instance);
+      if (!isValueProvider(provider)) {
+        this.trackCloseable(token, instance, provider.onClose);
+      }
+      return instance;
+    } finally {
+      this.resolving.delete(token);
+    }
+  }
+  async resolveClass(target) {
+    if (this.instances.has(target)) {
+      return this.instances.get(target);
+    }
+    if (this.resolving.has(target)) {
+      const path = [
+        ...this.resolving,
+        target
+      ].map(tokenToString).join(" \u2192 ");
+      throw new Error(`Circular dependency detected: ${path}`);
+    }
+    this.resolving.add(target);
+    try {
+      return this.constructClass(target);
+    } finally {
+      this.resolving.delete(target);
+    }
+  }
+  has(token) {
+    return this.instances.has(token) || this.providers.has(token);
+  }
+  getDependencies(token) {
+    return this.edges.get(token) ?? /* @__PURE__ */ new Set();
+  }
+  async closeAll() {
+    debug2("closeAll: %d resources", this.closeStack.length);
+    const entries = [
+      ...this.closeStack
+    ].reverse();
+    for (const entry of entries) {
+      try {
+        debug2("closing %s", tokenToString(entry.token));
+        await entry.close();
+      } catch {
+      }
+    }
+    this.closeStack = [];
+    this.trackedTokens.clear();
+  }
+  /**
+  * Validates that all registered providers have resolvable dependencies.
+  * Call after all module providers are registered but before resolution.
+  * Throws a descriptive error listing ALL missing dependencies at once.
+  */
+  validateDependencies() {
+    const missing = [];
+    const visited = /* @__PURE__ */ new Set();
+    const walk = /* @__PURE__ */ __name((token) => {
+      if (visited.has(token)) return;
+      visited.add(token);
+      let depTokens;
+      const provider = this.providers.get(token);
+      if (provider) {
+        depTokens = this.getProviderDependencyTokens(provider);
+      } else if (typeof token === "function") {
+        depTokens = this.getClassDependencyTokens(token);
+      } else {
+        return;
+      }
+      for (const dep of depTokens) {
+        if (this.providers.has(dep) || this.instances.has(dep)) {
+          walk(dep);
+        } else if (typeof dep === "function") {
+          walk(dep);
+        } else {
+          missing.push({
+            consumer: tokenToString(token),
+            dependency: tokenToString(dep)
+          });
+        }
+      }
+    }, "walk");
+    for (const token of this.providers.keys()) {
+      walk(token);
+    }
+    if (missing.length > 0) {
+      const details = missing.map(({ consumer, dependency }) => `  ${consumer} requires ${dependency} \u2014 no provider registered`).join("\n");
+      throw new Error(`Unresolvable dependencies detected during bootstrap:
+
+${details}
+
+For each unresolved dependency, check that the module providing it is included
+in your root module's "imports" array, or register a provider for it directly.`);
+    }
+  }
+  getClassDependencyTokens(target) {
+    return getClassDependencyTokens(target);
+  }
+  getProviderDependencyTokens(provider) {
+    return getProviderDependencyTokens(provider);
+  }
+  /**
+  * Constructs a class by resolving constructor dependencies via design:paramtypes.
+  * Does NOT manage the resolving set — callers (resolve/resolveClass) own cycle detection.
+  */
+  async constructClass(target) {
+    if (this.instances.has(target)) {
+      return this.instances.get(target);
+    }
+    const isInjectable = Reflect.getOwnMetadata(INJECTABLE_METADATA, target) === true;
+    if (!isInjectable && target.length > 0) {
+      throw new Error(`Class ${target.name} has constructor parameters but is not decorated with @Injectable(). Add @Injectable() to enable dependency injection, or use a factory provider.`);
+    }
+    const depTokens = this.getClassDependencyTokens(target);
+    debug2("construct %s deps=[%s]", target.name, depTokens.map(tokenToString).join(", "));
+    this.recordEdges(target, depTokens);
+    const deps = [];
+    for (const t of depTokens) {
+      deps.push(await this.resolve(t));
+    }
+    const instance = new target(...deps);
+    this.instances.set(target, instance);
+    this.trackCloseable(target, instance);
+    return instance;
+  }
+  recordEdges(from, to) {
+    let set = this.edges.get(from);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.edges.set(from, set);
+    }
+    for (const dep of to) {
+      set.add(dep);
+    }
+  }
+  trackCloseable(token, value, onClose) {
+    if (this.trackedTokens.has(token)) return;
+    if (onClose) {
+      this.closeStack.push({
+        token,
+        close: /* @__PURE__ */ __name(() => onClose(value), "close")
+      });
+      this.trackedTokens.add(token);
+      return;
+    }
+    const closeFn = detectCloseMethod(value);
+    if (closeFn) {
+      this.closeStack.push({
+        token,
+        close: closeFn
+      });
+      this.trackedTokens.add(token);
+    }
+  }
+  async createFromProvider(provider) {
+    if (isValueProvider(provider)) {
+      return provider.useValue;
+    }
+    if (isClassProvider2(provider)) {
+      return this.constructClass(provider.useClass);
+    }
+    if (isFactoryProvider2(provider)) {
+      const deps = provider.inject ? await Promise.all(provider.inject.map((t) => this.resolve(t))) : [];
+      return provider.useFactory(...deps);
+    }
+    throw new Error("Invalid provider configuration");
+  }
+};
+
+// src/di/tokens.ts
+var APP_CONFIG = /* @__PURE__ */ Symbol("celerity:app-config");
+var RUNTIME_APP = /* @__PURE__ */ Symbol("celerity:runtime-app");
+
+// src/application/factory.ts
+import createDebug8 from "debug";
+
+// src/bootstrap/bootstrap.ts
+import "reflect-metadata";
+import createDebug5 from "debug";
+
+// src/handlers/registry.ts
+import "reflect-metadata";
+import createDebug4 from "debug";
+import { joinHandlerPath } from "@celerity-sdk/common";
+
+// src/bootstrap/module-graph.ts
+import "reflect-metadata";
+import createDebug3 from "debug";
+var debug3 = createDebug3("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);
+      return;
+    }
+    if (resolving.has(moduleClass)) {
+      const cyclePath = [
+        ...importChain,
+        moduleClass
+      ].map((m) => m.name).join(" \u2192 ");
+      throw new Error(`Circular module import detected: ${cyclePath}`);
+    }
+    resolving.add(moduleClass);
+    const metadata = Reflect.getOwnMetadata(MODULE_METADATA, moduleClass);
+    if (!metadata) {
+      resolving.delete(moduleClass);
+      graph.set(moduleClass, {
+        moduleClass,
+        ownTokens: /* @__PURE__ */ new Set(),
+        exports: /* @__PURE__ */ new Set(),
+        imports: [],
+        controllers: [],
+        functionHandlers: [],
+        providers: []
+      });
+      return;
+    }
+    const imports = metadata.imports ?? [];
+    for (const imported of imports) {
+      walk(imported, [
+        ...importChain,
+        moduleClass
+      ]);
+    }
+    const ownTokens = /* @__PURE__ */ new Set();
+    const providers = metadata.providers ?? [];
+    for (const provider of providers) {
+      if (typeof provider === "function") {
+        ownTokens.add(provider);
+      } else {
+        const typed = provider;
+        ownTokens.add(typed.provide);
+      }
+    }
+    const controllers = metadata.controllers ?? [];
+    for (const controller of controllers) {
+      ownTokens.add(controller);
+    }
+    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);
+    graph.set(moduleClass, {
+      moduleClass,
+      ownTokens,
+      exports: exportTokens,
+      imports,
+      controllers,
+      functionHandlers: metadata.functionHandlers ?? [],
+      providers
+    });
+  }
+  __name(walk, "walk");
+  walk(rootModule, []);
+  return graph;
+}
+__name(buildModuleGraph, "buildModuleGraph");
+function registerModuleGraph(graph, container) {
+  for (const [, node] of graph) {
+    for (const provider of node.providers) {
+      if (typeof provider === "function") {
+        container.registerClass(provider);
+      } else {
+        const typed = provider;
+        container.register(typed.provide, typed);
+      }
+    }
+    for (const controller of node.controllers) {
+      if (!container.has(controller)) {
+        container.registerClass(controller);
+      }
+    }
+  }
+}
+__name(registerModuleGraph, "registerModuleGraph");
+function walkModuleGraph(rootModule, container) {
+  const graph = buildModuleGraph(rootModule);
+  registerModuleGraph(graph, container);
+  return graph;
+}
+__name(walkModuleGraph, "walkModuleGraph");
+function validateModuleGraph(graph, container) {
+  const diagnostics = [];
+  for (const [, node] of graph) {
+    for (const exportToken of node.exports) {
+      if (!node.ownTokens.has(exportToken)) {
+        diagnostics.push({
+          type: "invalid_export",
+          message: `${node.moduleClass.name} exports ${tokenToString(exportToken)}, but that token is not provided by this module.`
+        });
+      }
+    }
+    const visibleTokens = new Set(node.ownTokens);
+    for (const importedModule of node.imports) {
+      const importedNode = graph.get(importedModule);
+      if (importedNode) {
+        for (const exportedToken of importedNode.exports) {
+          visibleTokens.add(exportedToken);
+        }
+      }
+    }
+    for (const provider of node.providers) {
+      let depTokens;
+      let consumerToken;
+      if (typeof provider === "function") {
+        consumerToken = provider;
+        depTokens = getClassDependencyTokens(provider);
+      } else {
+        const typed = provider;
+        consumerToken = typed.provide;
+        depTokens = getProviderDependencyTokens(typed);
+      }
+      checkDependencies(consumerToken, depTokens, visibleTokens, node.moduleClass, graph, container, diagnostics);
+    }
+    for (const controller of node.controllers) {
+      const depTokens = getClassDependencyTokens(controller);
+      checkDependencies(controller, depTokens, visibleTokens, node.moduleClass, graph, container, diagnostics);
+    }
+  }
+  debug3("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:
+
+${details}`);
+  }
+}
+__name(validateModuleGraph, "validateModuleGraph");
+function checkDependencies(consumer, depTokens, visibleTokens, moduleClass, graph, container, diagnostics) {
+  for (const dep of depTokens) {
+    if (visibleTokens.has(dep)) continue;
+    const ownerModule = findTokenOwner(dep, graph);
+    if (ownerModule) {
+      const ownerNode = graph.get(ownerModule);
+      if (ownerNode.exports.has(dep)) {
+        diagnostics.push({
+          type: "export_violation",
+          message: `${tokenToString(consumer)} in ${moduleClass.name} depends on ${tokenToString(dep)}, which is exported from ${ownerModule.name} but ${moduleClass.name} does not import ${ownerModule.name}. Add ${ownerModule.name} to ${moduleClass.name}'s "imports" array.`
+        });
+      } else {
+        diagnostics.push({
+          type: "export_violation",
+          message: `${tokenToString(consumer)} in ${moduleClass.name} depends on ${tokenToString(dep)}, but ${tokenToString(dep)} is not exported from ${ownerModule.name}. Add ${tokenToString(dep)} to ${ownerModule.name}'s "exports" array.`
+        });
+      }
+      continue;
+    }
+    if (typeof dep === "function") {
+      if (!container.has(dep)) {
+        container.registerClass(dep);
+      }
+      visibleTokens.add(dep);
+      const adoptedDeps = getClassDependencyTokens(dep);
+      checkDependencies(dep, adoptedDeps, visibleTokens, moduleClass, graph, container, diagnostics);
+      continue;
+    }
+    diagnostics.push({
+      type: "missing_dependency",
+      message: `${tokenToString(consumer)} in ${moduleClass.name} requires ${tokenToString(dep)} \u2014 no provider registered. Ensure the module providing it is included in your module's "imports" array, or register a provider for it directly.`
+    });
+  }
+}
+__name(checkDependencies, "checkDependencies");
+function findTokenOwner(token, graph) {
+  for (const [, node] of graph) {
+    if (node.ownTokens.has(token)) {
+      return node.moduleClass;
+    }
+  }
+  return null;
+}
+__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;
+  }
+  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);
+      }
+    }
+  }
+  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));
+      }
+      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;
+    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));
+      }
+    }
+    debug4("registerFunctionHandler: %s", meta.method && meta.path ? `${meta.method} ${meta.path}` : "(no route)");
+    this.handlers.push({
+      path: meta.path,
+      method: meta.method,
+      protectedBy: [],
+      layers,
+      isPublic: false,
+      paramMetadata: [],
+      customMetadata: meta.customMetadata ?? {},
+      handlerFn: definition.handler,
+      isFunctionHandler: true,
+      injectTokens: meta.inject ?? []
+    });
+  }
+};
+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");
+var PARAM_TYPE_TO_SCHEMA_KEY = {
+  body: "body",
+  query: "query",
+  param: "params",
+  headers: "headers"
+};
+function buildValidationSchemasFromParams(paramMetadata) {
+  const wholeObjectSchemas = /* @__PURE__ */ new Map();
+  const perKeySchemas = /* @__PURE__ */ new Map();
+  for (const meta of paramMetadata) {
+    if (!meta.schema) continue;
+    const schemaKey = PARAM_TYPE_TO_SCHEMA_KEY[meta.type];
+    if (!schemaKey) continue;
+    if (meta.key) {
+      let keyMap = perKeySchemas.get(schemaKey);
+      if (!keyMap) {
+        keyMap = /* @__PURE__ */ new Map();
+        perKeySchemas.set(schemaKey, keyMap);
+      }
+      keyMap.set(meta.key, meta.schema);
+    } else {
+      wholeObjectSchemas.set(schemaKey, meta.schema);
+    }
+  }
+  const schemas = {};
+  let hasSchemas = false;
+  for (const key of [
+    "body",
+    "query",
+    "params",
+    "headers"
+  ]) {
+    if (wholeObjectSchemas.has(key)) {
+      schemas[key] = wholeObjectSchemas.get(key);
+      hasSchemas = true;
+    } else if (perKeySchemas.has(key)) {
+      schemas[key] = composeKeySchemas(perKeySchemas.get(key));
+      hasSchemas = true;
+    }
+  }
+  return hasSchemas ? schemas : null;
+}
+__name(buildValidationSchemasFromParams, "buildValidationSchemasFromParams");
+function composeKeySchemas(keySchemas) {
+  return {
+    parse(data) {
+      const record = data;
+      const result = {
+        ...record
+      };
+      for (const [key, schema] of keySchemas) {
+        if (key in result) {
+          result[key] = schema.parse(result[key]);
+        }
+      }
+      return result;
+    }
+  };
+}
+__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
+import createDebug6 from "debug";
+var debug6 = createDebug6("celerity:core:factory");
+var CelerityApplication = class {
+  static {
+    __name(this, "CelerityApplication");
+  }
+  registry;
+  container;
+  systemLayers;
+  appLayers;
+  runtimeApp;
+  constructor(registry, container, systemLayers = [], appLayers = [], runtimeApp) {
+    this.registry = registry;
+    this.container = container;
+    this.systemLayers = systemLayers;
+    this.appLayers = appLayers;
+    this.runtimeApp = runtimeApp;
+  }
+  async start() {
+    if (this.runtimeApp && typeof this.runtimeApp === "object") {
+      const app = this.runtimeApp;
+      await app.run(false);
+    }
+  }
+  async close() {
+    debug6("close: shutting down application");
+    if (this.runtimeApp && typeof this.runtimeApp === "object") {
+      const app = this.runtimeApp;
+      await app.shutdown();
+    }
+    await this.container.closeAll();
+    await disposeLayers([
+      ...this.systemLayers,
+      ...this.appLayers
+    ]);
+  }
+  getContainer() {
+    return this.container;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+  getSystemLayers() {
+    return this.systemLayers;
+  }
+  getAppLayers() {
+    return this.appLayers;
+  }
+};
+
+// src/application/serverless.ts
+var ServerlessApplication = class {
+  static {
+    __name(this, "ServerlessApplication");
+  }
+  registry;
+  container;
+  adapter;
+  systemLayers;
+  appLayers;
+  handler = null;
+  constructor(registry, container, adapter, systemLayers = [], appLayers = []) {
+    this.registry = registry;
+    this.container = container;
+    this.adapter = adapter;
+    this.systemLayers = systemLayers;
+    this.appLayers = appLayers;
+  }
+  async start() {
+    this.handler = this.adapter.createHandler(this.registry, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+    return this.handler;
+  }
+  async close() {
+    await this.container.closeAll();
+    await disposeLayers([
+      ...this.systemLayers,
+      ...this.appLayers
+    ]);
+  }
+  getHandler() {
+    if (!this.handler) {
+      throw new Error("ServerlessApplication.start() must be called before getHandler()");
+    }
+    return this.handler;
+  }
+  getContainer() {
+    return this.container;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+};
+
+// src/handlers/pipeline.ts
+import createDebug7 from "debug";
+
+// src/functions/context.ts
+function buildHttpRequest(request, metadata) {
+  const validatedBody = metadata.get("validatedBody");
+  let body;
+  if (validatedBody !== void 0) {
+    body = validatedBody;
+  } else if (request.binaryBody) {
+    body = request.binaryBody;
+  } else if (request.textBody) {
+    body = JSON.parse(request.textBody);
+  } else {
+    body = null;
+  }
+  return {
+    method: request.method,
+    path: request.path,
+    params: metadata.get("validatedParams") ?? request.pathParams,
+    query: metadata.get("validatedQuery") ?? request.query,
+    body,
+    headers: metadata.get("validatedHeaders") ?? request.headers,
+    cookies: request.cookies,
+    auth: request.auth,
+    clientIp: request.clientIp,
+    userAgent: request.userAgent,
+    contentType: request.contentType
+  };
+}
+__name(buildHttpRequest, "buildHttpRequest");
+function buildHttpContext(request, metadata, container, logger) {
+  return {
+    requestId: request.requestId,
+    requestTime: request.requestTime,
+    metadata,
+    container,
+    logger,
+    raw: request
+  };
+}
+__name(buildHttpContext, "buildHttpContext");
+
+// src/handlers/pipeline.ts
+var debug7 = createDebug7("celerity:core:pipeline");
+async function executeHandlerPipeline(handler, request, options) {
+  const context = {
+    request,
+    metadata: new HandlerMetadataStore(handler.customMetadata ?? {}),
+    container: options.container
+  };
+  const allLayers = [
+    ...options.systemLayers ?? [],
+    ...options.appLayers ?? [],
+    ...handler.layers
+  ];
+  debug7("%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 result = handler.isFunctionHandler ? await invokeFunctionHandler(handler, context) : await invokeClassHandler(handler, context);
+      return normalizeResponse(result);
+    });
+    debug7("response %d", response.status);
+    return response;
+  } catch (error) {
+    if (error instanceof HttpException) {
+      debug7("HttpException %d: %s", error.statusCode, error.message);
+      return {
+        status: error.statusCode,
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          message: error.message,
+          ...error.details ? {
+            details: error.details
+          } : {}
+        })
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (context.logger) {
+      context.logger.error("Unhandled error in handler pipeline", {
+        error: message,
+        ...error instanceof Error && error.stack ? {
+          stack: error.stack
+        } : {}
+      });
+    } else {
+      console.error("Unhandled error in handler pipeline:", error);
+    }
+    return {
+      status: 500,
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        message: "Internal Server Error"
+      })
+    };
+  }
+}
+__name(executeHandlerPipeline, "executeHandlerPipeline");
+async function invokeClassHandler(handler, context) {
+  const args = [];
+  const sorted = [
+    ...handler.paramMetadata
+  ].sort((a, b) => a.index - b.index);
+  for (const meta of sorted) {
+    args[meta.index] = extractValidatedParam(meta.type, meta.key, context.request, context.metadata);
+  }
+  return handler.handlerFn.apply(handler.handlerInstance, args);
+}
+__name(invokeClassHandler, "invokeClassHandler");
+var VALIDATED_METADATA_KEYS = {
+  body: "validatedBody",
+  query: "validatedQuery",
+  param: "validatedParams",
+  headers: "validatedHeaders"
+};
+function extractValidatedParam(type, key, request, metadata) {
+  const metaKey = VALIDATED_METADATA_KEYS[type];
+  if (metaKey) {
+    const validated = metadata.get(metaKey);
+    if (validated !== void 0) {
+      if (key && typeof validated === "object" && validated !== null) {
+        return validated[key];
+      }
+      return validated;
+    }
+  }
+  return extractParam(type, key, request);
+}
+__name(extractValidatedParam, "extractValidatedParam");
+async function invokeFunctionHandler(handler, context) {
+  const req = buildHttpRequest(context.request, context.metadata);
+  const ctx = buildHttpContext(context.request, context.metadata, context.container, context.logger);
+  if (handler.injectTokens && handler.injectTokens.length > 0) {
+    const deps = [];
+    for (const token of handler.injectTokens) {
+      deps.push(await context.container.resolve(token));
+    }
+    return handler.handlerFn(req, ctx, ...deps);
+  }
+  return handler.handlerFn(req, ctx);
+}
+__name(invokeFunctionHandler, "invokeFunctionHandler");
+function normalizeResponse(result) {
+  if (isHttpResponse(result)) {
+    return result;
+  }
+  if (result === void 0 || result === null) {
+    return {
+      status: 204
+    };
+  }
+  const body = typeof result === "string" ? result : JSON.stringify(result);
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json"
+    },
+    body
+  };
+}
+__name(normalizeResponse, "normalizeResponse");
+function isHttpResponse(value) {
+  return typeof value === "object" && value !== null && "status" in value && typeof value.status === "number";
+}
+__name(isHttpResponse, "isHttpResponse");
+
+// src/testing/test-app.ts
+var TestingApplication = class {
+  static {
+    __name(this, "TestingApplication");
+  }
+  registry;
+  container;
+  systemLayers;
+  appLayers;
+  constructor(registry, container, systemLayers = [], appLayers = []) {
+    this.registry = registry;
+    this.container = container;
+    this.systemLayers = systemLayers;
+    this.appLayers = appLayers;
+  }
+  async inject(request) {
+    const handler = this.registry.getHandler(request.path, request.method);
+    if (!handler) {
+      throw new NotFoundException(`No handler found for ${request.method} ${request.path}`);
+    }
+    return executeHandlerPipeline(handler, request, {
+      container: this.container,
+      systemLayers: this.systemLayers,
+      appLayers: this.appLayers
+    });
+  }
+  getContainer() {
+    return this.container;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+};
+function mockRequest(method, path, options = {}) {
+  return {
+    method,
+    path,
+    pathParams: options.pathParams ?? {},
+    query: options.query ?? {},
+    headers: options.headers ?? {},
+    cookies: options.cookies ?? {},
+    textBody: options.body !== void 0 ? JSON.stringify(options.body) : null,
+    binaryBody: null,
+    contentType: options.body !== void 0 ? "application/json" : null,
+    requestId: options.requestId ?? "test-request-id",
+    requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+    auth: options.auth ?? null,
+    clientIp: options.clientIp ?? "127.0.0.1",
+    traceContext: null,
+    userAgent: "celerity-testing",
+    matchedRoute: null
+  };
+}
+__name(mockRequest, "mockRequest");
+
+// src/application/factory.ts
+var debug8 = createDebug8("celerity:core:factory");
+var CelerityFactory = class {
+  static {
+    __name(this, "CelerityFactory");
+  }
+  static async create(rootModule, options) {
+    debug8("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);
+    const { container, registry } = await bootstrap(rootModule);
+    if (options?.adapter) {
+      debug8("create: using adapter \u2192 ServerlessApplication");
+      return new ServerlessApplication(registry, container, options.adapter, systemLayers, appLayers);
+    }
+    debug8("create: \u2192 CelerityApplication");
+    return new CelerityApplication(registry, container, systemLayers, appLayers);
+  }
+  static async createTestingApp(rootModule, options) {
+    debug8("createTestingApp: bootstrapping %s", rootModule.name);
+    const { container, registry } = await bootstrap(rootModule);
+    const systemLayers = options?.systemLayers ?? [];
+    const appLayers = options?.layers ?? [];
+    return new TestingApplication(registry, container, systemLayers, appLayers);
+  }
+};
+
+// src/functions/create-handler.ts
+function createHttpHandler(config, handler) {
+  const metadata = {
+    schema: config.schema,
+    layers: config.layers ?? [],
+    inject: config.inject ?? [],
+    customMetadata: config.metadata ?? {}
+  };
+  if (config.path !== void 0) metadata.path = config.path;
+  if (config.method !== void 0) metadata.method = config.method;
+  return {
+    __celerity_handler: true,
+    type: "http",
+    metadata,
+    handler
+  };
+}
+__name(createHttpHandler, "createHttpHandler");
+function httpGet(path, handlerOrOptions, maybeHandler) {
+  if (typeof handlerOrOptions === "function") {
+    return createHttpHandler({
+      path,
+      method: "GET"
+    }, handlerOrOptions);
+  }
+  return createHttpHandler({
+    path,
+    method: "GET",
+    ...handlerOrOptions
+  }, maybeHandler);
+}
+__name(httpGet, "httpGet");
+function httpPost(path, handlerOrOptions, maybeHandler) {
+  if (typeof handlerOrOptions === "function") {
+    return createHttpHandler({
+      path,
+      method: "POST"
+    }, handlerOrOptions);
+  }
+  return createHttpHandler({
+    path,
+    method: "POST",
+    ...handlerOrOptions
+  }, maybeHandler);
+}
+__name(httpPost, "httpPost");
+function httpPut(path, handlerOrOptions, maybeHandler) {
+  if (typeof handlerOrOptions === "function") {
+    return createHttpHandler({
+      path,
+      method: "PUT"
+    }, handlerOrOptions);
+  }
+  return createHttpHandler({
+    path,
+    method: "PUT",
+    ...handlerOrOptions
+  }, maybeHandler);
+}
+__name(httpPut, "httpPut");
+function httpPatch(path, handlerOrOptions, maybeHandler) {
+  if (typeof handlerOrOptions === "function") {
+    return createHttpHandler({
+      path,
+      method: "PATCH"
+    }, handlerOrOptions);
+  }
+  return createHttpHandler({
+    path,
+    method: "PATCH",
+    ...handlerOrOptions
+  }, maybeHandler);
+}
+__name(httpPatch, "httpPatch");
+function httpDelete(path, handlerOrOptions, maybeHandler) {
+  if (typeof handlerOrOptions === "function") {
+    return createHttpHandler({
+      path,
+      method: "DELETE"
+    }, handlerOrOptions);
+  }
+  return createHttpHandler({
+    path,
+    method: "DELETE",
+    ...handlerOrOptions
+  }, maybeHandler);
+}
+__name(httpDelete, "httpDelete");
+
+// src/bootstrap/discovery.ts
+import { resolve } from "path";
+import createDebug9 from "debug";
+var debug9 = createDebug9("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 = resolve(resolved);
+  debug9("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}"`);
+  }
+  debug9("discoverModule: found %s", rootModule.name);
+  return rootModule;
+}
+__name(discoverModule, "discoverModule");
+function findModuleExport(imported) {
+  for (const key of Object.keys(imported)) {
+    if (key === "default") continue;
+    if (typeof imported[key] === "function") {
+      return imported[key];
+    }
+  }
+  return void 0;
+}
+__name(findModuleExport, "findModuleExport");
+
+// src/bootstrap/runtime-mapper.ts
+function flattenMultiValueRecord(record) {
+  const result = {};
+  for (const [key, values] of Object.entries(record)) {
+    result[key] = values.length === 1 ? values[0] : values;
+  }
+  return result;
+}
+__name(flattenMultiValueRecord, "flattenMultiValueRecord");
+function mapRuntimeRequest(request) {
+  return {
+    method: request.method.toUpperCase(),
+    path: request.path,
+    pathParams: request.pathParams,
+    query: flattenMultiValueRecord(request.query),
+    headers: flattenMultiValueRecord(request.headers),
+    cookies: request.cookies,
+    textBody: request.textBody,
+    binaryBody: request.binaryBody,
+    contentType: request.contentType || null,
+    requestId: request.requestId,
+    requestTime: request.requestTime,
+    auth: request.auth ?? null,
+    clientIp: request.clientIp || null,
+    traceContext: request.traceContext ?? null,
+    userAgent: request.userAgent || null,
+    matchedRoute: request.matchedRoute
+  };
+}
+__name(mapRuntimeRequest, "mapRuntimeRequest");
+function mapToRuntimeResponse(response) {
+  return {
+    status: response.status,
+    headers: response.headers,
+    body: response.body,
+    binaryBody: response.binaryBody
+  };
+}
+__name(mapToRuntimeResponse, "mapToRuntimeResponse");
+
+// src/bootstrap/runtime-entry.ts
+async function bootstrapForRuntime(modulePath, systemLayers) {
+  const layers = systemLayers ?? await createDefaultSystemLayers();
+  const rootModule = await discoverModule(modulePath);
+  const { container, registry } = await bootstrap(rootModule);
+  return {
+    registry,
+    container,
+    createRouteCallback(path, method) {
+      const handler = registry.getHandler(path, method);
+      if (!handler) return null;
+      return async (_err, request) => {
+        const httpRequest = mapRuntimeRequest(request);
+        const httpResponse = await executeHandlerPipeline(handler, httpRequest, {
+          container,
+          systemLayers: layers
+        });
+        return mapToRuntimeResponse(httpResponse);
+      };
+    }
+  };
+}
+__name(bootstrapForRuntime, "bootstrapForRuntime");
+
+// src/bootstrap/runtime-orchestrator.ts
+async function startRuntime(options) {
+  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);
+    if (callback) {
+      app.registerHttpHandler(def.path, def.method, def.timeout, callback);
+    }
+  }
+  await app.run(options?.block ?? true);
+}
+__name(startRuntime, "startRuntime");
+export {
+  APP_CONFIG,
+  Action,
+  Auth,
+  BadGatewayException,
+  BadRequestException,
+  Body,
+  CONTROLLER_METADATA,
+  CUSTOM_METADATA,
+  CelerityApplication,
+  CelerityFactory,
+  ConflictException,
+  Container,
+  Controller,
+  Cookies,
+  Delete,
+  ForbiddenException,
+  GUARD_CUSTOM_METADATA,
+  GUARD_PROTECTEDBY_METADATA,
+  GatewayTimeoutException,
+  Get,
+  GoneException,
+  Guard,
+  HTTP_METHOD_METADATA,
+  HandlerMetadataStore,
+  HandlerRegistry,
+  Head,
+  Headers,
+  HttpException,
+  INJECT_METADATA,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+  LAYER_METADATA,
+  MODULE_METADATA,
+  MethodNotAllowedException,
+  Module,
+  NotAcceptableException,
+  NotFoundException,
+  NotImplementedException,
+  Options,
+  PUBLIC_METADATA,
+  Param,
+  Patch,
+  Post,
+  ProtectedBy,
+  Public,
+  Put,
+  Query,
+  ROUTE_PATH_METADATA,
+  RUNTIME_APP,
+  Req,
+  RequestId,
+  ServerlessApplication,
+  ServiceUnavailableException,
+  SetMetadata,
+  TestingApplication,
+  TooManyRequestsException,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  UseLayer,
+  UseLayers,
+  bootstrap,
+  bootstrapForRuntime,
+  buildModuleGraph,
+  createDefaultSystemLayers,
+  createHttpHandler,
+  discoverModule,
+  disposeLayers,
+  executeHandlerPipeline,
+  flattenMultiValueRecord,
+  getClassDependencyTokens,
+  getProviderDependencyTokens,
+  httpDelete,
+  httpGet,
+  httpPatch,
+  httpPost,
+  httpPut,
+  mapRuntimeRequest,
+  mapToRuntimeResponse,
+  mockRequest,
+  registerModuleGraph,
+  runLayerPipeline,
+  startRuntime,
+  tokenToString,
+  validate
+};
+//# sourceMappingURL=index.js.map