@getstrata/bootstrap 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @getstrata/bootstrap changelog
 
+## 2.2.0
+
+Consistent model scopes.
+Changed-field model writes.
+Awaited provider startup.
+Shared cache correctness.
+Native HTTP controls and body limits.
+Graceful lifecycle.
+Validated async discovery.
+Stronger model input types.
+OpenTelemetry tracing.
+Distributed scheduler ownership.
+App-owned quota policy.
+Bounded memory throttling.
+
+## Unreleased
+
+- Provide shared tracing provider ownership and phased OpenTelemetry flush/shutdown without replacing application global tracer providers.
+
+- Breaking source contract: `discoverJobs()` and `discoverListeners()` now return promises. Await ESM discovery before queue construction or listener boot; malformed exports and duplicate discovered identities fail visibly. Add explicit job/listener/module manifests for bundles, preserve custom job factories, evict failed discovery loads and protect publication after reset. See `docs/DISCOVERY.md` before release/adoption.
+
+- Make provider startup awaited, register all providers before boot, and expose idempotent context disposal with failure cleanup. Direct startup helper callers must now await; appContext getters require completed startup.
+
+- Add awaited model discovery with nested exports, two-phase naming/boot, duplicate-name detection and startup error propagation.
+
 ## 2.1.0
 
 - refactor(starter): reuse shared config and base repositories - fix(database): await password casts before model writes - fix(database): preserve concrete model types in query results

package/README.md

@@ -48,7 +48,7 @@ HTML apps should bind `createCookieSessionAuthManager` from `@getstrata/bootstra
 
 ## Queue
 
-`registerDefaultJobs()` registers `cache.invalidate-tags` and `audit.export` only. Outbound model webhooks are not a core job. Put a class with `static jobName` in `src/jobs/` (generated `--webhooks` uses `webhook.dispatch`) and call `discoverJobs()` on boot. `queue:work` already does that. There is no `registerWebhookJobs()` export.
+`registerDefaultJobs()` registers `cache.invalidate-tags` and `audit.export` only. Outbound model webhooks are not a core job. Put a class with `static jobName` in `src/jobs/` (generated `--webhooks` uses `webhook.dispatch`) and call `await discoverJobs()` on boot. `queue:work` already does that. There is no `registerWebhookJobs()` export.
 
 ## Not a starter API
 

package/dist/bootstrap/app.d.ts

@@ -1,6 +1,12 @@
+import { type ShutdownResult } from "@getstrata/core/lifecycle/gracefulShutdown";
 declare class App {
     private server?;
-    serve(): void;
+    private startup?;
+    private lifecycle?;
+    private uninstallSignals?;
+    serve(): Promise<void>;
+    private start;
+    shutdown(reason?: string): Promise<ShutdownResult>;
     stop(force?: boolean): void;
     private resolvePort;
 }

package/dist/bootstrap/config.d.ts

@@ -4,7 +4,7 @@ declare const CACHE_MAX_ENTRIES_CONFIG_KEY = "cache.maxEntries";
 declare const CACHE_DRIVER_CONFIG_KEY = "cache.driver";
 declare const REDIS_URL_CONFIG_KEY = "cache.redisUrl";
 declare const DATABASE_URL_CONFIG_KEY = "database.url";
-export { CORE_ABILITY_CHECKER_TOKEN, CORE_AUTH_TOKEN, CORE_AUTH_USER_DIRECTORY_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_EVENT_BUS_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, } from "@getstrata/core/contracts/serviceTokens";
+export { CORE_ABILITY_CHECKER_TOKEN, CORE_AUTH_TOKEN, CORE_AUTH_USER_DIRECTORY_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_EVENT_BUS_TOKEN, CORE_HTTP_CLEANUP_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TENANT_RESOLVER_TOKEN, CORE_THROTTLE_QUOTA_POLICY_TOKEN, CORE_TOKEN_SERVICE_TOKEN, } from "@getstrata/core/contracts/serviceTokens";
 declare const AUTH_DEV_HEADERS_CONFIG_KEY = "auth.allowDevHeaders";
 declare const DEFAULT_APP_PORT = 3000;
 declare const DEFAULT_CACHE_TTL_MS = 3600000;

package/dist/bootstrap/context.d.ts

@@ -1,6 +1,12 @@
 import { type AppContext, type AppModule, type ProviderContext, type ServiceProvider } from "./contracts";
+type InitializedAppContext = AppContext & {
+    drain(): Promise<void>;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+};
 declare function collectProviders(modules?: AppModule[]): ServiceProvider[];
-declare function runProviderPhase(providers: ServiceProvider[], phase: "register" | "boot", context: ProviderContext): void;
-declare function createAppContext(): AppContext;
+declare function runProviderPhase(providers: readonly ServiceProvider[], phase: "register" | "boot", context: ProviderContext): Promise<void>;
+declare function createAppContext(providers?: readonly ServiceProvider[]): Promise<InitializedAppContext>;
 declare const appContext: AppContext;
+export type { InitializedAppContext };
 export { appContext, collectProviders, createAppContext, runProviderPhase };

package/dist/bootstrap/dependencies.d.ts

@@ -1,4 +1,4 @@
 import { createAppContext } from "./context";
-declare function createAppDependencies(): import("./contracts").AppDependencies;
+declare function createAppDependencies(): Promise<import("./contracts").AppDependencies>;
 export type { AppContext, AppDependencies } from "./contracts";
 export { createAppContext, createAppDependencies };

package/dist/bootstrap/discoverJobs.d.ts

@@ -1,8 +1,16 @@
-import type { Job } from "@getstrata/core/queue";
+import { Job } from "@getstrata/core/queue";
+import { type InfrastructureDiscoveryOptions } from "./infrastructureDiscovery";
 type DiscoveredJobClass = (new () => Job) & {
     jobName: string;
 };
-declare function discoverJobs(): string[];
+type JobManifestEntry = DiscoveredJobClass | {
+    name: string;
+    create: () => Job;
+};
+interface DiscoverJobsOptions extends InfrastructureDiscoveryOptions {
+    manifest?: readonly JobManifestEntry[];
+}
+declare function discoverJobs(options?: DiscoverJobsOptions): Promise<string[]>;
 declare function resetDiscoverJobsForTests(): void;
-export type { DiscoveredJobClass };
+export type { DiscoveredJobClass, DiscoverJobsOptions, JobManifestEntry };
 export { discoverJobs, resetDiscoverJobsForTests };

package/dist/bootstrap/discoverListeners.d.ts

@@ -1,5 +1,9 @@
-type ListenerRegistrar = () => void;
-declare function discoverListeners(): ListenerRegistrar[];
+import { type InfrastructureDiscoveryOptions } from "./infrastructureDiscovery";
+type ListenerRegistrar = () => void | Promise<void>;
+interface DiscoverListenersOptions extends InfrastructureDiscoveryOptions {
+    manifest?: readonly ListenerRegistrar[];
+}
+declare function discoverListeners(options?: DiscoverListenersOptions): Promise<ListenerRegistrar[]>;
 declare function resetDiscoverListenersForTests(): void;
-export type { ListenerRegistrar };
+export type { DiscoverListenersOptions, ListenerRegistrar };
 export { discoverListeners, resetDiscoverListenersForTests };

package/dist/bootstrap/discoverModels.d.ts

@@ -0,0 +1,8 @@
+/** Import trusted application model modules, then bind and boot their exported classes. */
+interface DiscoverModelsOptions {
+    /** Startup orchestration files are not model modules; avoids importing the awaiting caller. */
+    exclude?: readonly string[];
+}
+declare function discoverModels(directory?: string, options?: DiscoverModelsOptions): Promise<object[]>;
+export type { DiscoverModelsOptions };
+export { discoverModels };

package/dist/bootstrap/discoverModules.d.ts

@@ -1,10 +1,13 @@
 import type { AppModule } from "./contracts";
 interface DiscoverModulesOptions {
     modulesDir?: string;
+    exclude?: readonly string[];
+    manifest?: readonly AppModule[];
 }
 declare function configureModulesDirectory(modulesDir: string): void;
+declare function configureModulesManifest(manifest: readonly AppModule[]): void;
 declare function ensureModulesLoaded(options?: DiscoverModulesOptions): Promise<AppModule[]>;
 declare function discoverModules(): AppModule[];
 declare function resetDiscoverModulesForTests(): void;
 export type { DiscoverModulesOptions };
-export { configureModulesDirectory, discoverModules, ensureModulesLoaded, resetDiscoverModulesForTests, };
+export { configureModulesDirectory, configureModulesManifest, discoverModules, ensureModulesLoaded, resetDiscoverModulesForTests, };

package/dist/bootstrap/httpKernel.d.ts

@@ -6,7 +6,12 @@ type MiddlewareGroupName = "api" | "authenticated" | "web";
 type WebGuestHome = string | ((user: AuthUser) => string | Promise<string>);
 declare class HttpKernel {
     private readonly dependencies;
+    private readonly ownedThrottles;
+    private disposed;
     constructor(dependencies: AppDependencies);
+    dispose(): void;
+    /** Own custom disposable throttle middleware until this application closes. */
+    ownThrottle<T extends Middleware>(throttle: T): T;
     globalMiddleware(errorFormat?: "json" | "web"): Middleware[];
     group(name: MiddlewareGroupName): Middleware[];
     wrap<TRequest extends Request = Request>(groups: MiddlewareGroupName | MiddlewareGroupName[], handler: RouteHandler<TRequest>): RouteHandler<TRequest>;

package/dist/bootstrap/inProcessCron.d.ts

@@ -1,4 +1,5 @@
 import "./schedule";
 declare function startInProcessCronIfEnabled(): void;
 declare function stopInProcessCron(): void;
-export { startInProcessCronIfEnabled, stopInProcessCron };
+declare function drainInProcessCron(): Promise<void>;
+export { drainInProcessCron, startInProcessCronIfEnabled, stopInProcessCron };

package/dist/bootstrap/infrastructureDiscovery.d.ts

@@ -0,0 +1,9 @@
+interface InfrastructureDiscoveryOptions {
+    directory?: string;
+    /** Relative paths or basenames; exclusions apply before importing. */
+    exclude?: readonly string[];
+}
+declare function infrastructureFiles(directory: string, exclude?: readonly string[]): Promise<string[]>;
+declare function importInfrastructure(file: string): Promise<Record<string, unknown>>;
+export type { InfrastructureDiscoveryOptions };
+export { importInfrastructure, infrastructureFiles };

package/dist/bootstrap/modules.d.ts

@@ -1 +1 @@
-export { configureModulesDirectory, discoverModules, ensureModulesLoaded, } from "./discoverModules";
+export { configureModulesDirectory, configureModulesManifest, discoverModules, ensureModulesLoaded, } from "./discoverModules";

package/dist/bootstrap/providers/tracing.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceProvider } from "../contracts";
+declare const tracingProvider: ServiceProvider;
+export default tracingProvider;

package/dist/bootstrap/public-api.d.ts

@@ -1,8 +1,8 @@
 /**
  * @getstrata/bootstrap: application shell for Strata apps.
  */
-export type { ScheduledTask } from "@getstrata/core/scheduler/schedule";
-export { appSchedule, runDueScheduledTasks, Schedule } from "@getstrata/core/scheduler/schedule";
+export type { ScheduledTask, ScheduledTaskContext, SchedulerLease, SchedulerLeaseStore, SchedulerRunOptions, } from "@getstrata/core/scheduler/schedule";
+export { appSchedule, RedisSchedulerLeaseStore, runDueScheduledTasks, Schedule, SchedulerLeaseLostError, } from "@getstrata/core/scheduler/schedule";
 export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationEventBus, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, } from "./applicationRegistry.ts";
 export type { BuildModuleRoutesOptions } from "./buildModuleRoutes.ts";
 export { buildModuleRoutes } from "./buildModuleRoutes.ts";
@@ -10,15 +10,19 @@ export type { BuildWebModuleRoutesOptions } from "./buildWebModuleRoutes.ts";
 export { buildWebModuleRoutes } from "./buildWebModuleRoutes.ts";
 export { cacheTagsForModelWrite, discoverModelTableNames } from "./cache/modelCacheTags.ts";
 export { APP_PORT_CONFIG_KEY, CORE_ABILITY_CHECKER_TOKEN, CORE_AUTH_TOKEN, CORE_AUTH_USER_DIRECTORY_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_EVENT_BUS_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_APP_PORT, REDIS_URL_CONFIG_KEY, } from "./config.ts";
+export type { InitializedAppContext } from "./context.ts";
 export { collectProviders, createAppContext, runProviderPhase } from "./context.ts";
 export type { AppContext, AppDependencies, AppModule, AppRouteMap, CachedJson, ConfigStore, ModuleRouteContext, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, } from "./contracts.ts";
 export { assertAppDependenciesComplete, getRequiredDependency, resolveService, ServiceContainer, } from "./contracts.ts";
 export type { CreateWebRoutesOptions } from "./createWebRoutes.ts";
 export { createWebRoutes, mergeWebRoutes } from "./createWebRoutes.ts";
 export { createAppDependencies } from "./dependencies.ts";
+export type { DiscoveredJobClass, DiscoverJobsOptions, JobManifestEntry } from "./discoverJobs.ts";
 export { discoverJobs, resetDiscoverJobsForTests } from "./discoverJobs.ts";
+export type { DiscoverModelsOptions } from "./discoverModels.ts";
+export { discoverModels } from "./discoverModels.ts";
 export type { DiscoverModulesOptions } from "./discoverModules.ts";
-export { configureModulesDirectory, discoverModules, ensureModulesLoaded, } from "./discoverModules.ts";
+export { configureModulesDirectory, configureModulesManifest, discoverModules, ensureModulesLoaded, } from "./discoverModules.ts";
 export type { CreateHealthRoutesOptions } from "./health.ts";
 export { checkDatabase, checkRedis, createHealthRoutes, pingDatabase } from "./health.ts";
 export { type RouteModelAuthorization, securedBindRouteModel, securedBindRouteModelByKey, } from "./http/securedRouteModelBinding.ts";
@@ -26,7 +30,8 @@ export { createHttpKernel, type HttpKernel, type MiddlewareGroupName } from "./h
 export { resolveMembershipService } from "./membershipService.ts";
 export { prefixRouteMap } from "./prefixRouteMap.ts";
 export { coreProviders } from "./providers/index.ts";
+export { default as tracingProvider } from "./providers/tracing.ts";
 export { registerDefaultJobs } from "./queue/defaultJobs.ts";
 export { RouteRegistry, routeRegistry } from "./routeRegistry.ts";
 export { assertProductionSecrets } from "./secretsGuard.ts";
-export { CookieSessionAuthManager, CookieSessionGuard, CookieSessionStore, createCookieSessionAuthManager, createCsrfProtection, createRouteKernel, createWebServer, type LoadSessionUser, type MapSessionUser, type ParsedForm, parseFormBody, routeParams, type SessionUser, slugify, toRouteRequest, type WebServerOptions, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./web/index.ts";
+export { CookieSessionAuthManager, CookieSessionGuard, CookieSessionStore, createCookieSessionAuthManager, createCsrfProtection, createRouteKernel, createWebServer, type LoadSessionUser, type MapSessionUser, type NativeServerOptions, type ParsedForm, parseFormBody, routeParams, type SessionUser, slugify, toRouteRequest, type WebServerOptions, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./web/index.ts";

package/dist/bootstrap/web/index.d.ts

@@ -3,6 +3,6 @@
  */
 export { createCsrfProtection, type ParsedForm, parseFormBody } from "./forms.ts";
 export { createRouteKernel, routeParams, toRouteRequest, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./routing.ts";
-export { convertAppRoutesToBunRoutes, createWebServer, type WebServerOptions } from "./server.ts";
+export { convertAppRoutesToBunRoutes, createWebServer, type NativeServerOptions, type WebServerOptions, } from "./server.ts";
 export { CookieSessionAuthManager, CookieSessionGuard, CookieSessionStore, createCookieSessionAuthManager, type LoadSessionUser, type MapSessionUser, type SessionUser, } from "./session.ts";
 export { slugify } from "./slug.ts";

package/dist/bootstrap/web/server.d.ts

@@ -1,16 +1,24 @@
 import { type CorsOptions } from "@getstrata/core/http/corsMiddleware";
-import type { BunRequest, Server } from "bun";
+import type { LifecycleCoordinator } from "@getstrata/core/lifecycle/gracefulShutdown";
+import type { BunRequest, Serve, Server } from "bun";
 import type { AppRouteMap } from "../contracts.ts";
-export interface WebServerOptions {
+export type NativeServerOptions<T = unknown> = Omit<Serve.HostnamePortServeOptions<T>, "port"> & {
+    websocket?: Bun.WebSocketHandler<T>;
+};
+export interface WebServerOptions<T = unknown> {
     port: number;
-    handle?: (request: Request) => Promise<Response | null> | Response | null;
+    handle?: (request: Request, server: Server<T>) => Promise<Response | null | undefined> | Response | null | undefined;
+    /** Bun transport options. Framework dispatch and route composition remain owned here. */
+    native?: NativeServerOptions<T>;
+    lifecycle?: LifecycleCoordinator;
     routes?: AppRouteMap;
     publicDir?: string;
     /** Additional approved headers for synthesized route preflights; origins still use framework policy. */
     cors?: CorsOptions;
-    onRequest?: (request: Request) => Promise<void> | void;
+    onRequest?: (request: Request, server: Server<T>) => Promise<void | Response> | void | Response;
 }
-type BunRouteHandler = (request: BunRequest, server: Server<unknown>) => Response | Promise<Response>;
-declare function convertAppRoutesToBunRoutes(routes: AppRouteMap, cors?: CorsOptions): Record<string, Record<string, BunRouteHandler>>;
-export declare function createWebServer(options: WebServerOptions): Server<undefined>;
+type TrackRequest = <T>(work: () => Promise<T>) => Promise<T>;
+type BunRouteHandler<T = unknown> = (request: BunRequest, server: Server<T>) => Response | Promise<Response>;
+declare function convertAppRoutesToBunRoutes<T = unknown>(routes: AppRouteMap, cors?: CorsOptions, onRequest?: WebServerOptions<T>["onRequest"], track?: TrackRequest): Record<string, Record<string, BunRouteHandler<T>>>;
+export declare function createWebServer<T = unknown>(options: WebServerOptions<T>): Server<T>;
 export { convertAppRoutesToBunRoutes };

package/dist/entries/buildModuleRoutes.js

@@ -50,8 +50,11 @@ import {
   CORE_CACHE_TOKEN,
   CORE_CONFIG_TOKEN,
   CORE_EVENT_BUS_TOKEN,
+  CORE_HTTP_CLEANUP_TOKEN,
   CORE_POLICY_GATE_TOKEN,
   CORE_QUEUE_TOKEN,
+  CORE_TENANT_RESOLVER_TOKEN,
+  CORE_THROTTLE_QUOTA_POLICY_TOKEN,
   CORE_TOKEN_SERVICE_TOKEN
 } from "@getstrata/core/contracts/serviceTokens";
 var APP_PORT_CONFIG_KEY = "app.port";
@@ -117,8 +120,39 @@ function resolveRegisterRateLimit() {
 // ../../src/bootstrap/httpKernel.ts
 class HttpKernel {
   dependencies;
+  ownedThrottles = new Set;
+  disposed = false;
   constructor(dependencies) {
     this.dependencies = dependencies;
+    if (dependencies.container.has(CORE_HTTP_CLEANUP_TOKEN)) {
+      dependencies.container.resolve(CORE_HTTP_CLEANUP_TOKEN)(() => this.dispose());
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    const owned = [...this.ownedThrottles];
+    this.ownedThrottles.clear();
+    const errors = [];
+    for (const throttle of owned.reverse()) {
+      try {
+        throttle.dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length)
+      throw new AggregateError(errors, "HTTP throttle cleanup failed.");
+  }
+  ownThrottle(throttle) {
+    if (this.disposed) {
+      if ("dispose" in throttle && typeof throttle.dispose === "function")
+        throttle.dispose();
+      throw new Error("HTTP kernel is disposed.");
+    }
+    if ("dispose" in throttle && typeof throttle.dispose === "function") {
+      this.ownedThrottles.add(throttle);
+    }
+    return throttle;
   }
   globalMiddleware(errorFormat = "json") {
     const auth = this.dependencies.container.resolve(CORE_AUTH_TOKEN);
@@ -133,7 +167,9 @@ class HttpKernel {
       errorFormat === "json" ? createJsonErrorMiddleware() : createWebErrorMiddleware(),
       createAuthMiddleware(auth),
       createMembershipMiddleware(),
-      createTenantMiddleware()
+      createTenantMiddleware({
+        resolveTenant: this.dependencies.container.has(CORE_TENANT_RESOLVER_TOKEN) ? this.dependencies.container.resolve(CORE_TENANT_RESOLVER_TOKEN) : undefined
+      })
     ];
   }
   group(name) {
@@ -148,25 +184,28 @@ class HttpKernel {
         if (!this.dependencies.container.has(CORE_CONFIG_TOKEN)) {
           return [csrf];
         }
+        const quotaPolicy = this.dependencies.container.has(CORE_THROTTLE_QUOTA_POLICY_TOKEN) ? this.dependencies.container.resolve(CORE_THROTTLE_QUOTA_POLICY_TOKEN) : undefined;
         const config = this.dependencies.container.resolve(CORE_CONFIG_TOKEN);
         const redisUrl = config.get(REDIS_URL_CONFIG_KEY)?.trim() ?? "";
         if (!redisUrl) {
           const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
           return [
-            createMemoryThrottleMiddleware({
+            this.ownThrottle(createMemoryThrottleMiddleware({
               maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-              decaySeconds: 60
-            }),
+              decaySeconds: 60,
+              quotaPolicy
+            })),
             csrf
           ];
         }
         const maxAttempts = Number(process.env.RATE_LIMIT_PER_MINUTE ?? "120");
         return [
-          createThrottleMiddleware({
+          this.ownThrottle(createThrottleMiddleware({
             redisUrl,
             maxAttempts: Number.isFinite(maxAttempts) ? maxAttempts : 120,
-            decaySeconds: 60
-          }),
+            decaySeconds: 60,
+            quotaPolicy
+          })),
           csrf
         ];
       }
@@ -296,25 +335,25 @@ class HttpKernel {
     const memoryKeyPrefix = scope === "login" ? "login-throttle:" : "register-throttle:";
     const redisUrl = this.dependencies.container.has(CORE_CONFIG_TOKEN) ? this.dependencies.container.resolve(CORE_CONFIG_TOKEN).get(REDIS_URL_CONFIG_KEY)?.trim() ?? "" : "";
     if (scope === "login") {
-      return withMiddleware(createLoginThrottleMiddleware({
+      return withMiddleware(this.ownThrottle(createLoginThrottleMiddleware({
         ...redisUrl ? { redisUrl } : {},
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds
-      }))(handler);
+      })))(handler);
     }
     if (redisUrl) {
-      return withMiddleware(createThrottleMiddleware({
+      return withMiddleware(this.ownThrottle(createThrottleMiddleware({
         redisUrl,
         maxAttempts: rateLimit.maxAttempts,
         decaySeconds: rateLimit.decaySeconds,
         keyPrefix: memoryKeyPrefix
-      }))(handler);
+      })))(handler);
     }
-    return withMiddleware(createMemoryThrottleMiddleware({
+    return withMiddleware(this.ownThrottle(createMemoryThrottleMiddleware({
       maxAttempts: rateLimit.maxAttempts,
       decaySeconds: rateLimit.decaySeconds,
       keyPrefix: memoryKeyPrefix
-    }))(handler);
+    })))(handler);
   }
 }
 function createHttpKernel(dependencies) {
@@ -322,74 +361,180 @@ function createHttpKernel(dependencies) {
 }
 
 // ../../src/bootstrap/discoverModules.ts
-import { readdirSync } from "fs";
-import { join } from "path";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join2, resolve } from "path";
+
+// ../../src/bootstrap/infrastructureDiscovery.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
 import { pathToFileURL } from "url";
-var DISCOVER_MODULES_STATE_KEY = Symbol.for("@getstrata/discoverModulesState");
-function readDiscoverModulesState() {
-  const existing = globalThis[DISCOVER_MODULES_STATE_KEY];
-  if (existing) {
-    return existing;
-  }
-  const state = { appModules: [] };
-  globalThis[DISCOVER_MODULES_STATE_KEY] = state;
-  return state;
-}
-function configureModulesDirectory(modulesDir) {
-  const state = readDiscoverModulesState();
-  if (state.configuredModulesDir !== modulesDir) {
-    state.appModules.length = 0;
-    state.modulesReady = undefined;
-  }
-  state.configuredModulesDir = modulesDir;
-}
-function resolveModulesDirectory(options) {
-  const state = readDiscoverModulesState();
-  if (options?.modulesDir) {
-    return options.modulesDir;
+async function infrastructureFiles(directory, exclude = []) {
+  const excluded = new Set([
+    "index.ts",
+    "index.js",
+    "index.mts",
+    "index.mjs",
+    "register.ts",
+    "register.js",
+    "register.mts",
+    "register.mjs",
+    ...exclude
+  ]);
+  const files = [];
+  async function visit(path) {
+    const entries = await readdir(path, { withFileTypes: true });
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const file = join(path, entry.name);
+      const key = relative(directory, file).replaceAll("\\", "/");
+      if (excluded.has(entry.name) || excluded.has(key))
+        continue;
+      if (entry.isDirectory())
+        await visit(file);
+      else if (entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name) && !/\.(d|test|spec)\.[cm]?[jt]s$/.test(entry.name))
+        files.push(file);
+    }
   }
-  if (state.configuredModulesDir) {
-    return state.configuredModulesDir;
+  try {
+    await visit(directory);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    if (error.path !== directory)
+      throw error;
   }
-  throw new Error("configureModulesDirectory() must be called before discovering modules. The app preload (or starter) should call it.");
+  return files;
 }
-async function loadDiscoveredModules(options) {
-  const modulesDirectory = resolveModulesDirectory(options);
-  let moduleNames;
+async function importInfrastructure(file) {
   try {
-    moduleNames = readdirSync(modulesDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return await import(pathToFileURL(file).href);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
+    throw new Error(`Cannot load infrastructure module ${file}`, { cause: error });
+  }
+}
+
+// ../../src/bootstrap/discoverModules.ts
+var KEY = Symbol.for("@getstrata/discoverModulesState");
+function state() {
+  const globals = globalThis;
+  globals[KEY] ??= { appModules: [] };
+  return globals[KEY];
+}
+function configureModulesDirectory(modulesDir) {
+  const current = state();
+  const directory = resolve(modulesDir);
+  if (current.configuredModulesDir !== directory || current.configuredManifest) {
+    current.appModules.length = 0;
+    current.modulesReady = undefined;
+    current.source = undefined;
+  }
+  current.configuredManifest = undefined;
+  current.configuredModulesDir = directory;
+}
+function configureModulesManifest(manifest) {
+  const current = state();
+  if (current.configuredManifest !== manifest) {
+    current.appModules.length = 0;
+    current.modulesReady = undefined;
+    current.source = undefined;
+  }
+  current.configuredManifest = manifest;
+}
+function validateModule(value, location) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(`Invalid application module at ${location}.`);
+  const module = value;
+  if (typeof module.name !== "string" || !module.name.trim())
+    throw new TypeError(`Invalid module name at ${location}.`);
+  if (module.order !== undefined && (typeof module.order !== "number" || !Number.isFinite(module.order)))
+    throw new TypeError(`Invalid module order at ${location}.`);
+  for (const hook of ["routes", "webRoutes"])
+    if (module[hook] !== undefined && typeof module[hook] !== "function")
+      throw new TypeError(`Invalid ${hook} at ${location}.`);
+  if (module.providers !== undefined) {
+    if (!Array.isArray(module.providers))
+      throw new TypeError(`Invalid providers at ${location}.`);
+    for (const provider of module.providers) {
+      if (!provider || typeof provider.name !== "string" || !provider.name.trim() || provider.register !== undefined && typeof provider.register !== "function" || provider.boot !== undefined && typeof provider.boot !== "function")
+        throw new TypeError(`Invalid provider at ${location}.`);
     }
-    throw error;
   }
-  const modules = await Promise.all(moduleNames.map(async (moduleName) => {
-    const moduleUrl = pathToFileURL(join(modulesDirectory, moduleName, "index.ts")).href;
-    const loaded = await import(moduleUrl);
-    return loaded.default;
-  }));
-  return modules.filter((module) => module?.name !== undefined).sort((left, right) => (left.order ?? 100) - (right.order ?? 100));
 }
-async function ensureModulesLoaded(options) {
-  const state = readDiscoverModulesState();
-  if (state.appModules.length > 0) {
-    return state.appModules;
-  }
-  state.modulesReady ??= loadDiscoveredModules(options).then((modules) => {
-    state.appModules.splice(0, state.appModules.length, ...modules);
-    return state.appModules;
+async function load(options) {
+  const manifest = options.manifest ?? (options.modulesDir === undefined ? state().configuredManifest : undefined);
+  const entries = [];
+  if (manifest)
+    for (const [index, value] of manifest.entries())
+      entries.push({ value, location: `module manifest[${index}]` });
+  else {
+    const directory = options.modulesDir ?? state().configuredModulesDir;
+    if (!directory)
+      throw new Error("configureModulesDirectory() or configureModulesManifest() must be called before discovering modules.");
+    let folders;
+    try {
+      folders = await readdir2(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+    const excluded = new Set(options.exclude ?? []);
+    for (const folder of folders.filter((entry) => entry.isDirectory() && !excluded.has(entry.name)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const path = join2(directory, folder.name);
+      const files = await readdir2(path);
+      const candidates = files.filter((file) => /^index\.(ts|js|mts|mjs)$/.test(file));
+      if (candidates.length !== 1)
+        throw new Error(`Expected one module entrypoint at ${path}; found ${candidates.length}.`);
+      const file = join2(path, candidates[0]);
+      const exports = await importInfrastructure(file);
+      entries.push({ value: exports.default, location: file });
+    }
+  }
+  const names = new Map;
+  const modules = [];
+  for (const { value, location } of entries) {
+    validateModule(value, location);
+    const previous = names.get(value.name);
+    if (previous)
+      throw new Error(`Duplicate module "${value.name}" at ${location}; first declared at ${previous}.`);
+    names.set(value.name, location);
+    modules.push(value);
+  }
+  return modules.sort((left, right) => (left.order ?? 100) - (right.order ?? 100));
+}
+function ensureModulesLoaded(options = {}) {
+  const current = state();
+  const key = options.manifest ?? (options.modulesDir === undefined ? current.configuredManifest : undefined) ?? JSON.stringify([
+    options.modulesDir ? resolve(options.modulesDir) : current.configuredModulesDir,
+    [...options.exclude ?? []].sort()
+  ]);
+  if (current.modulesReady && current.source === key)
+    return current.modulesReady;
+  current.appModules.length = 0;
+  current.source = key;
+  const pending = load(options).then((modules) => {
+    if (current.modulesReady !== pending)
+      return modules;
+    current.appModules.splice(0, current.appModules.length, ...modules);
+    return current.appModules;
+  }).catch((error) => {
+    if (current.modulesReady === pending)
+      current.modulesReady = undefined;
+    throw error;
   });
-  return state.modulesReady;
+  current.modulesReady = pending;
+  return pending;
 }
 function discoverModules() {
-  return readDiscoverModulesState().appModules;
+  return state().appModules;
 }
 function resetDiscoverModulesForTests() {
-  const state = readDiscoverModulesState();
-  state.configuredModulesDir = undefined;
-  state.appModules.length = 0;
-  state.modulesReady = undefined;
+  const current = state();
+  current.configuredModulesDir = undefined;
+  current.configuredManifest = undefined;
+  current.appModules.length = 0;
+  current.modulesReady = undefined;
+  current.source = undefined;
 }
 // ../../src/bootstrap/prefixRouteMap.ts
 function prefixRouteMap(prefix, routes) {