@getstrata/bootstrap 2.0.9 → 2.2.0

package/dist/index.js

@@ -1,6 +1,12 @@
 // @bun
 // ../../src/bootstrap/public-api.ts
-import { appSchedule, runDueScheduledTasks, Schedule } from "@getstrata/core/scheduler/schedule";
+import {
+  appSchedule,
+  RedisSchedulerLeaseStore,
+  runDueScheduledTasks,
+  Schedule,
+  SchedulerLeaseLostError
+} from "@getstrata/core/scheduler/schedule";
 
 // ../../src/bootstrap/applicationRegistry.ts
 import {
@@ -65,8 +71,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";
@@ -131,8 +140,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);
@@ -147,7 +187,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) {
@@ -162,25 +204,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
         ];
       }
@@ -310,25 +355,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) {
@@ -336,68 +381,172 @@ 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;
+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);
+    }
   }
-  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;
+  try {
+    await visit(directory);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    if (error.path !== directory)
+      throw error;
   }
-  state.configuredModulesDir = modulesDir;
+  return files;
 }
-function resolveModulesDirectory(options) {
-  const state = readDiscoverModulesState();
-  if (options?.modulesDir) {
-    return options.modulesDir;
+async function importInfrastructure(file) {
+  try {
+    return await import(pathToFileURL(file).href);
+  } catch (error) {
+    throw new Error(`Cannot load infrastructure module ${file}`, { cause: error });
   }
-  if (state.configuredModulesDir) {
-    return state.configuredModulesDir;
+}
+
+// ../../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 new Error("configureModulesDirectory() must be called before discovering modules. The app preload (or starter) should call it.");
 }
-async function loadDiscoveredModules(options) {
-  const modulesDirectory = resolveModulesDirectory(options);
-  let moduleNames;
-  try {
-    moduleNames = readdirSync(modulesDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
+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 });
     }
-    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;
+  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;
 }
 // ../../src/bootstrap/prefixRouteMap.ts
 function prefixRouteMap(prefix, routes) {
@@ -527,9 +676,14 @@ function cacheTagsForModelWrite(tableName, action) {
 function discoverModelTableNames() {
   return discoverModules().map((module) => module.tableName).filter((tableName) => tableName !== undefined);
 }
+// ../../src/bootstrap/context.ts
+import { CORE_HTTP_CLEANUP_TOKEN as CORE_HTTP_CLEANUP_TOKEN2 } from "@getstrata/core/contracts/serviceTokens";
+import { clearActiveApplicationContext } from "@getstrata/core/runtime/applicationRegistry";
+
 // ../../src/bootstrap/contracts.ts
 import {
   ConfigStore,
+  createServiceToken,
   ServiceContainer
 } from "@getstrata/core/contracts/container";
 import {
@@ -586,7 +740,7 @@ import { createCacheStore } from "@getstrata/core/cache/createCacheStore";
 import { CacheRepository } from "@getstrata/core/cache/repository";
 var cacheProvider = {
   name: "core.cache",
-  register({ container, config, dependencies }) {
+  register({ container, config, dependencies, onCleanup }) {
     container.singleton(CORE_CACHE_TOKEN, () => {
       const store = createCacheStore({
         driver: config.require(CACHE_DRIVER_CONFIG_KEY),
@@ -594,7 +748,9 @@ var cacheProvider = {
         maxEntries: config.require(CACHE_MAX_ENTRIES_CONFIG_KEY),
         redisUrl: config.get(REDIS_URL_CONFIG_KEY) || undefined
       });
-      return new CacheRepository(store);
+      const cache = new CacheRepository(store);
+      onCleanup(() => cache.close());
+      return cache;
     });
     dependencies.cache = container.resolve(CORE_CACHE_TOKEN);
   }
@@ -791,49 +947,47 @@ var eventsProvider = {
 var events_default = eventsProvider;
 
 // ../../src/bootstrap/discoverListeners.ts
-import { existsSync, readdirSync as readdirSync2 } from "fs";
-import { createRequire } from "module";
-import { join as join2 } from "path";
-var requireListener = createRequire(import.meta.url);
-var DISCOVER_LISTENERS_STATE_KEY = Symbol.for("@getstrata/discoverListenersState");
-function readDiscoverListenersState() {
-  const existing = globalThis[DISCOVER_LISTENERS_STATE_KEY];
-  if (existing) {
-    return existing;
-  }
-  const state = {};
-  globalThis[DISCOVER_LISTENERS_STATE_KEY] = state;
-  return state;
-}
-function resolveListenersDirectory() {
-  const fromCwd = join2(process.cwd(), "src", "listeners");
-  if (existsSync(fromCwd)) {
-    return fromCwd;
-  }
-  return join2(import.meta.dir, "../listeners");
-}
-function loadDiscoveredListeners() {
-  const listenersDirectory = resolveListenersDirectory();
-  let entries;
-  try {
-    entries = readdirSync2(listenersDirectory, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.(ts|js)$/.test(entry.name)).map((entry) => entry.name);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return [];
+import { join as join3, resolve as resolve2 } from "path";
+var KEY2 = Symbol.for("@getstrata/discoverListenersState");
+function state2() {
+  const globals = globalThis;
+  globals[KEY2] ??= { loads: new Map };
+  return globals[KEY2];
+}
+async function load2(options) {
+  const listeners = new Set;
+  const add = (value, location) => {
+    if (typeof value !== "function")
+      throw new TypeError(`Invalid listener registrar at ${location}: expected a default function.`);
+    listeners.add(value);
+  };
+  if (options.manifest)
+    for (const [index, value] of options.manifest.entries())
+      add(value, `listener manifest[${index}]`);
+  else
+    for (const file of await infrastructureFiles(options.directory ?? join3(process.cwd(), "src", "listeners"), options.exclude)) {
+      const exports = await importInfrastructure(file);
+      const value = exports.default;
+      add(value && typeof value === "object" && "default" in value ? value.default : value, file);
     }
+  return [...listeners];
+}
+function discoverListeners(options = {}) {
+  const cache = state2().loads;
+  const key = options.manifest ?? JSON.stringify([
+    resolve2(options.directory ?? join3(process.cwd(), "src", "listeners")),
+    [...options.exclude ?? []].sort()
+  ]);
+  const existing = cache.get(key);
+  if (existing)
+    return existing;
+  const pending = load2(options).catch((error) => {
+    if (cache.get(key) === pending)
+      cache.delete(key);
     throw error;
-  }
-  const listeners = entries.map((fileName) => {
-    const filePath = join2(listenersDirectory, fileName);
-    const loaded = requireListener(filePath);
-    return loaded.default;
   });
-  return listeners.filter((listener) => typeof listener === "function");
-}
-function discoverListeners() {
-  const state = readDiscoverListenersState();
-  state.appListeners ??= loadDiscoveredListeners();
-  return state.appListeners;
+  cache.set(key, pending);
+  return pending;
 }
 
 // ../../src/bootstrap/listeners/invalidateCacheOnModelWrite.ts
@@ -926,22 +1080,12 @@ function registerInvalidateCacheOnModelWriteListeners(bus = eventBus2, options =
 }
 
 // ../../src/bootstrap/providers/listeners.ts
-var registeredListenerGroups = new Set;
-function registerListenerGroup(name, register) {
-  if (registeredListenerGroups.has(name)) {
-    return;
-  }
-  registeredListenerGroups.add(name);
-  register();
-}
 var listenersProvider = {
   name: "core.listeners",
-  boot() {
-    registerListenerGroup("cache.invalidate-on-model-write", () => {
-      registerInvalidateCacheOnModelWriteListeners();
-    });
-    for (const registerListener of discoverListeners()) {
-      registerListener();
+  async boot({ onCleanup }) {
+    onCleanup(registerInvalidateCacheOnModelWriteListeners());
+    for (const registerListener of await discoverListeners()) {
+      await registerListener();
     }
   }
 };
@@ -965,68 +1109,99 @@ import {
 } from "@getstrata/core/queue/createAppQueue";
 
 // ../../src/bootstrap/discoverJobs.ts
-import { existsSync as existsSync2, readdirSync as readdirSync3 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { join as join3 } from "path";
+import { join as join4, resolve as resolve3 } from "path";
+import { Job } from "@getstrata/core/queue";
 import { jobRegistry } from "@getstrata/core/queue/jobRegistry";
-var requireJob = createRequire2(import.meta.url);
-var DISCOVER_JOBS_STATE_KEY = Symbol.for("@getstrata/discoverJobsState");
-function readDiscoverJobsState() {
-  const existing = globalThis[DISCOVER_JOBS_STATE_KEY];
-  if (existing) {
-    return existing;
-  }
-  const state = {};
-  globalThis[DISCOVER_JOBS_STATE_KEY] = state;
-  return state;
-}
-function resolveJobsDirectory() {
-  const fromCwd = join3(process.cwd(), "src", "jobs");
-  if (existsSync2(fromCwd)) {
-    return fromCwd;
+var KEY3 = Symbol.for("@getstrata/discoverJobsState");
+function state3() {
+  const globals = globalThis;
+  globals[KEY3] ??= { loads: new Map, registered: new Map };
+  return globals[KEY3];
+}
+function validateClass(value, location) {
+  if (typeof value !== "function" || typeof value.jobName !== "string" || !value.jobName.trim() || !(value.prototype instanceof Job) && typeof value.prototype?.handle !== "function")
+    throw new TypeError(`Invalid job at ${location}: expected a class with nonempty static jobName and handle().`);
+}
+async function load3(options, current) {
+  const jobs = new Map;
+  const add = (name, identity, create, location) => {
+    const previous = jobs.get(name);
+    if (previous && previous.identity !== identity)
+      throw new Error(`Duplicate job "${name}" at ${location}; first declared at ${previous.location}.`);
+    if (!previous)
+      jobs.set(name, { identity, create, location });
+  };
+  if (options.manifest) {
+    for (const [index, entry] of options.manifest.entries()) {
+      const location = `job manifest[${index}]`;
+      if (typeof entry === "function") {
+        validateClass(entry, location);
+        add(entry.jobName, entry, () => new entry, location);
+      } else {
+        if (!entry || typeof entry.name !== "string" || !entry.name.trim() || typeof entry.create !== "function")
+          throw new TypeError(`Invalid job factory at ${location}.`);
+        add(entry.name, entry.create, entry.create, location);
+      }
+    }
+  } else {
+    for (const file of await infrastructureFiles(options.directory ?? join4(process.cwd(), "src", "jobs"), options.exclude)) {
+      const exports = await importInfrastructure(file);
+      const defaultValue = exports.default;
+      const legacy = defaultValue && typeof defaultValue === "object" && "default" in defaultValue ? defaultValue.default : defaultValue;
+      if (legacy !== undefined)
+        validateClass(legacy, `${file}:default`);
+      let found = false;
+      for (const [name, value] of Object.entries({
+        ...exports,
+        ...legacy === undefined ? {} : { default: legacy }
+      })) {
+        if (name !== "default" && !(typeof value === "function" && ("jobName" in value)))
+          continue;
+        validateClass(value, `${file}:${name}`);
+        found = true;
+        add(value.jobName, value, () => new value, `${file}:${name}`);
+      }
+      if (!found)
+        throw new TypeError(`No job exports at ${file}; exclude helper modules explicitly.`);
+    }
   }
-  return join3(import.meta.dir, "../jobs");
-}
-function isDiscoveredJobClass(value) {
-  if (typeof value !== "function") {
-    return false;
+  if (!current())
+    return [...jobs.keys()];
+  const registered = state3().registered;
+  for (const [name, entry] of jobs) {
+    const previous = registered.get(name);
+    if (previous && previous.identity !== entry.identity)
+      throw new Error(`Duplicate discovered job "${name}" at ${entry.location}; first declared at ${previous.location}.`);
+  }
+  const existing = new Set(jobRegistry.names());
+  for (const [name, entry] of jobs) {
+    if (!existing.has(name)) {
+      jobRegistry.register(name, entry.create);
+      registered.set(name, entry);
+    }
   }
-  const jobName = value.jobName;
-  return typeof jobName === "string" && jobName.length > 0;
+  return [...jobs.keys()];
 }
-function loadDiscoveredJobClasses() {
-  const jobsDirectory = resolveJobsDirectory();
-  let entries;
-  try {
-    entries = readdirSync3(jobsDirectory, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.(ts|js)$/.test(entry.name)).map((entry) => entry.name);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return [];
-    }
+function discoverJobs(options = {}) {
+  const cache = state3().loads;
+  const key = options.manifest ?? JSON.stringify([
+    resolve3(options.directory ?? join4(process.cwd(), "src", "jobs")),
+    [...options.exclude ?? []].sort()
+  ]);
+  const existing = cache.get(key);
+  if (existing)
+    return existing;
+  const pending = load3(options, () => state3().loads === cache).catch((error) => {
+    if (cache.get(key) === pending)
+      cache.delete(key);
     throw error;
-  }
-  return entries.flatMap((fileName) => {
-    const filePath = join3(jobsDirectory, fileName);
-    const loaded = requireJob(filePath);
-    return isDiscoveredJobClass(loaded.default) ? [loaded.default] : [];
   });
-}
-function discoverJobs() {
-  const state = readDiscoverJobsState();
-  if (state.names) {
-    return state.names;
-  }
-  const names = [];
-  for (const JobClass of loadDiscoveredJobClasses()) {
-    jobRegistry.register(JobClass.jobName, () => new JobClass);
-    names.push(JobClass.jobName);
-  }
-  state.names = names;
-  return names;
+  cache.set(key, pending);
+  return pending;
 }
 function resetDiscoverJobsForTests() {
-  const state = readDiscoverJobsState();
-  state.names = undefined;
+  state3().loads = new Map;
+  state3().registered = new Map;
 }
 
 // ../../src/bootstrap/queue/defaultJobs.ts
@@ -1044,16 +1219,17 @@ function registerDefaultJobs() {
 // ../../src/bootstrap/providers/queue.ts
 var queueProvider = {
   name: "core.queue",
-  register({ container, config }) {
+  async register({ container, config, onCleanup }) {
     const configuredDriver = process.env.QUEUE_DRIVER ?? DEFAULT_QUEUE_DRIVER;
     const driver = configuredDriver === "async" || configuredDriver === "redis" || configuredDriver === "sync" ? configuredDriver : DEFAULT_QUEUE_DRIVER;
     config.set("queue.driver", driver);
     const failedJobs = createFailedJobService();
     container.set(FAILED_JOB_SERVICE_TOKEN, failedJobs);
-    container.set(CORE_QUEUE_TOKEN, createAppQueue(driver, config.get(REDIS_URL_CONFIG_KEY) ?? process.env.REDIS_URL, failedJobs, () => {
-      registerDefaultJobs();
-      discoverJobs();
-    }));
+    registerDefaultJobs();
+    await discoverJobs();
+    const queue = createAppQueue(driver, config.get(REDIS_URL_CONFIG_KEY) ?? process.env.REDIS_URL, failedJobs);
+    onCleanup(() => queue.close?.(), driver === "async" ? "drain" : "close");
+    container.set(CORE_QUEUE_TOKEN, queue);
   }
 };
 var queue_default = queueProvider;
@@ -1068,6 +1244,18 @@ var storageProvider = {
 };
 var storage_default = storageProvider;
 
+// ../../src/bootstrap/providers/tracing.ts
+import { acquireTracingRuntime } from "@getstrata/core/tracing/tracingMiddleware";
+var tracingProvider = {
+  name: "core.tracing",
+  register({ onCleanup }) {
+    const ownership = acquireTracingRuntime();
+    onCleanup(() => ownership.flush(), "flush");
+    onCleanup(() => ownership.release(), "close");
+  }
+};
+var tracing_default = tracingProvider;
+
 // ../../src/bootstrap/providers/view.ts
 import { currentRequestMeta } from "@getstrata/core/http/requestMetaContext";
 import { appDisplayName } from "@getstrata/core/runtime/appKeyPrefix";
@@ -1112,6 +1300,7 @@ var viewProvider = {
 // ../../src/bootstrap/providers/index.ts
 var coreProviders = [
   config_default,
+  tracing_default,
   cache_default,
   storage_default,
   auth_default,
@@ -1126,36 +1315,127 @@ var coreProviders = [
 function collectProviders(modules = discoverModules()) {
   return [...coreProviders, ...modules.flatMap((module) => module.providers ?? [])];
 }
-function runProviderPhase(providers, phase, context) {
-  for (const provider of providers) {
-    provider[phase]?.(context);
-  }
+async function runProviderPhase(providers, phase, context) {
+  for (const provider of providers)
+    await provider[phase]?.(context);
 }
-function createAppContext() {
+var readyContext;
+async function createAppContext(providers) {
+  if (!providers)
+    await ensureModulesLoaded();
+  const configured = [...providers ?? collectProviders()];
   const container = new ServiceContainer;
   const config = new ConfigStore;
-  const dependencies = {
-    container
+  const dependencies = { container };
+  const cleanups = [];
+  const drains = [];
+  let draining;
+  const drain = () => {
+    draining ??= (async () => {
+      const errors = [];
+      for (const handler of drains.splice(0).reverse()) {
+        try {
+          await handler();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length)
+        throw new AggregateError(errors, "Provider drain failed.");
+    })();
+    return draining;
   };
-  const context = {
-    container,
-    config,
-    dependencies
+  const flushes = [];
+  let flushing;
+  const flush = () => {
+    flushing ??= (async () => {
+      const errors = [];
+      for (const handler of flushes.splice(0).reverse()) {
+        try {
+          await handler();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length)
+        throw new AggregateError(errors, "Provider flush failed.");
+    })();
+    return flushing;
+  };
+  let disposal;
+  let disposed = false;
+  let initialized;
+  const dispose = () => {
+    disposed = true;
+    disposal ??= (async () => {
+      await drain();
+      const errors = [];
+      try {
+        await flush();
+      } catch (error) {
+        errors.push(error);
+      }
+      if (initialized) {
+        clearActiveApplicationContext(initialized);
+        if (readyContext === initialized)
+          readyContext = undefined;
+      }
+      for (const handler of cleanups.splice(0).reverse()) {
+        try {
+          await handler();
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length)
+        throw new AggregateError(errors, "Provider cleanup failed.");
+    })();
+    return disposal;
   };
-  const providers = collectProviders();
-  runProviderPhase(providers, "register", context);
-  runProviderPhase(providers, "boot", context);
-  assertAppDependenciesComplete(dependencies);
-  const appContext = {
+  const context = {
     container,
     config,
-    dependencies
+    dependencies,
+    onCleanup(handler, phase = "close") {
+      if (disposed)
+        throw new Error("Cannot register cleanup on a disposed application context.");
+      if (phase !== "drain" && phase !== "flush" && phase !== "close")
+        throw new TypeError("Unknown provider cleanup phase.");
+      if (phase === "drain" && draining || phase === "flush" && flushing)
+        throw new Error("Cannot register cleanup after its phase started.");
+      (phase === "drain" ? drains : phase === "flush" ? flushes : cleanups).push(handler);
+    }
   };
-  setActiveApplicationContext(appContext);
-  return appContext;
+  container.set(CORE_HTTP_CLEANUP_TOKEN2, (handler) => context.onCleanup(handler));
+  try {
+    await runProviderPhase(configured, "register", context);
+    await runProviderPhase(configured, "boot", context);
+    assertAppDependenciesComplete(dependencies);
+    const appContext = {
+      container,
+      config,
+      dependencies,
+      drain,
+      flush,
+      dispose
+    };
+    initialized = appContext;
+    setActiveApplicationContext(appContext);
+    readyContext = appContext;
+    return appContext;
+  } catch (error) {
+    try {
+      await dispose();
+    } catch (cleanupError) {
+      throw new AggregateError([error, cleanupError], "Application startup and cleanup failed.", {
+        cause: error
+      });
+    }
+    throw error;
+  }
 }
 // ../../src/bootstrap/createWebRoutes.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { isViewsEnabled as isViewsEnabled3 } from "@getstrata/core/runtime/frontendMode";
 import { assertUrlPathUnderRoot } from "@getstrata/core/security/safePath";
 import { notFoundHtmlResponse } from "@getstrata/core/view";
@@ -1172,7 +1452,7 @@ function createWebRoutes(dependencies, options = {}) {
     registerRoute("GET", "/assets/*", ["global", "web"]);
     const pathname = new URL(request.url).pathname;
     try {
-      const filePath = assertUrlPathUnderRoot(join4(process.cwd(), "public"), pathname);
+      const filePath = assertUrlPathUnderRoot(join5(process.cwd(), "public"), pathname);
       const file = Bun.file(filePath);
       if (!await file.exists()) {
         return notFoundHtmlResponse();
@@ -1195,8 +1475,43 @@ function mergeWebRoutes(dependencies, routes, options = {}) {
   };
 }
 // ../../src/bootstrap/dependencies.ts
-function createAppDependencies() {
-  return createAppContext().dependencies;
+async function createAppDependencies() {
+  return (await createAppContext()).dependencies;
+}
+// ../../src/bootstrap/discoverModels.ts
+import { readdir as readdir3 } from "fs/promises";
+import { join as join6 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { bootModels, Model } from "@getstrata/core/database/model";
+async function discoverModels(directory = join6(process.cwd(), "src", "models"), options = {}) {
+  const excluded = new Set([
+    "register.ts",
+    "register.js",
+    "index.ts",
+    "index.js",
+    ...options.exclude ?? []
+  ]);
+  const models = new Set;
+  async function visit(path) {
+    const entries = await readdir3(path, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const file = join6(path, entry.name);
+      if (entry.isDirectory())
+        await visit(file);
+      else if (!excluded.has(entry.name) && entry.isFile() && /\.(ts|js|mts|mjs)$/.test(entry.name) && !/\.d\.[cm]?ts$/.test(entry.name)) {
+        const exports = await import(pathToFileURL2(file).href);
+        for (const value of Object.values(exports)) {
+          if (typeof value === "function" && value.prototype instanceof Model)
+            models.add(value);
+        }
+      }
+    }
+  }
+  await visit(directory);
+  const result = [...models];
+  bootModels(result);
+  return result;
 }
 // ../../src/bootstrap/health.ts
 import { getBoundDatabaseConnection } from "@getstrata/core/database/boundConnection";
@@ -1579,6 +1894,7 @@ function createRouteKernel(dependencies) {
   return createHttpKernel(dependencies);
 }
 // ../../src/bootstrap/web/server.ts
+import { resolveMaxBodyBytes } from "@getstrata/core/http/bodySizeLimitMiddleware";
 import { createCorsMiddleware as createCorsMiddleware2 } from "@getstrata/core/http/corsMiddleware";
 import { currentRequestMeta as currentRequestMeta2, runWithRequestMeta } from "@getstrata/core/http/requestMetaContext";
 import { assertUrlPathUnderRoot as assertUrlPathUnderRoot2 } from "@getstrata/core/security/safePath";
@@ -1590,29 +1906,32 @@ function socketAddress(server, request) {
 async function missingHtmlResponse() {
   return notFoundHtmlResponse2();
 }
-function wrapRouteHandler(handler, path) {
+function wrapRouteHandler(handler, path, onRequest, track = (work) => work()) {
   return async (request, server) => {
-    return await runWithRequestMeta({
+    return await track(async () => await runWithRequestMeta({
       ...currentRequestMeta2(),
       request,
       routeTemplate: path,
       ipAddress: socketAddress(server, request),
       userAgent: request.headers.get("user-agent")
     }, async () => {
+      const intercepted = await onRequest?.(request, server);
+      if (intercepted instanceof Response)
+        return intercepted;
       const response = await handler(request);
       return response ?? await missingHtmlResponse();
-    });
+    }));
   };
 }
-function convertAppRoutesToBunRoutes(routes, cors = {}) {
+function convertAppRoutesToBunRoutes(routes, cors = {}, onRequest, track) {
   const bunRoutes = {};
   const middleware = createCorsMiddleware2(cors);
   const preflight = (request) => middleware(request, async () => new Response(null, { status: 405 }));
   for (const [path, handler] of Object.entries(routes)) {
     if (typeof handler === "function") {
       bunRoutes[path] = {
-        GET: wrapRouteHandler(handler, path),
-        OPTIONS: wrapRouteHandler(preflight, path)
+        GET: wrapRouteHandler(handler, path, onRequest, track),
+        OPTIONS: wrapRouteHandler(preflight, path, onRequest, track)
       };
       continue;
     }
@@ -1622,10 +1941,10 @@ function convertAppRoutesToBunRoutes(routes, cors = {}) {
         if (typeof methodHandler !== "function") {
           continue;
         }
-        methods[method.toUpperCase()] = wrapRouteHandler(methodHandler, path);
+        methods[method.toUpperCase()] = wrapRouteHandler(methodHandler, path, onRequest, track);
       }
       if (Object.keys(methods).length > 0) {
-        methods.OPTIONS ??= wrapRouteHandler(preflight, path);
+        methods.OPTIONS ??= wrapRouteHandler(preflight, path, onRequest, track);
         bunRoutes[path] = methods;
       }
     }
@@ -1633,19 +1952,47 @@ function convertAppRoutesToBunRoutes(routes, cors = {}) {
   return bunRoutes;
 }
 function createWebServer(options) {
+  if (options.lifecycle?.isShuttingDown)
+    throw new Error("Cannot start HTTP during shutdown.");
+  const onRequest = (request, server) => {
+    if (options.lifecycle?.isShuttingDown)
+      return new Response("Service Unavailable", { status: 503 });
+    return options.onRequest?.(request, server);
+  };
+  for (const field of ["fetch", "routes", "port", "unix"])
+    if (options.native && field in options.native)
+      throw new TypeError(`native.${field} is owned by createWebServer.`);
+  const maxRequestBodySize = options.native?.maxRequestBodySize ?? resolveMaxBodyBytes();
+  if (!Number.isSafeInteger(maxRequestBodySize) || maxRequestBodySize <= 0)
+    throw new RangeError("maxRequestBodySize must be a positive safe integer.");
+  const active = new Set;
+  const track = (work) => {
+    if (!options.lifecycle)
+      return work();
+    const running = work();
+    active.add(running);
+    return running.finally(() => {
+      active.delete(running);
+    });
+  };
   const publicDir = options.publicDir ?? "./public";
-  const bunRoutes = options.routes ? convertAppRoutesToBunRoutes(options.routes, options.cors) : undefined;
-  return Bun.serve({
+  const bunRoutes = options.routes ? convertAppRoutesToBunRoutes(options.routes, options.cors, onRequest, track) : undefined;
+  const { websocket, ...native } = options.native ?? {};
+  const configuration = {
+    ...native,
+    maxRequestBodySize,
     port: options.port,
     ...bunRoutes ? { routes: bunRoutes } : {},
     async fetch(request, server) {
-      return await runWithRequestMeta({
+      return await track(async () => await runWithRequestMeta({
         ...currentRequestMeta2(),
         request,
         ipAddress: socketAddress(server, request),
         userAgent: request.headers.get("user-agent")
       }, async () => {
-        await options.onRequest?.(request);
+        const intercepted = await onRequest(request, server);
+        if (intercepted instanceof Response)
+          return intercepted;
         const url = new URL(request.url);
         if (url.pathname.startsWith("/assets/")) {
           try {
@@ -1659,13 +2006,36 @@ function createWebServer(options) {
           }
         }
         if (options.handle) {
-          const response = await options.handle(request);
+          const response = await options.handle(request, server);
+          if (response === undefined && websocket)
+            return;
           return response ?? await missingHtmlResponse();
         }
         return await missingHtmlResponse();
-      });
+      }));
+    }
+  };
+  const server = websocket ? Bun.serve({ ...configuration, websocket }) : Bun.serve({
+    ...configuration,
+    async fetch(request, server) {
+      return await configuration.fetch(request, server) ?? await missingHtmlResponse();
     }
   });
+  if (options.lifecycle) {
+    const lifecycle = options.lifecycle;
+    const name = `http:${crypto.randomUUID()}`;
+    let draining;
+    lifecycle.register(`${name}:stop`, () => {
+      draining ??= server.stop(false);
+      draining.catch(() => {});
+    }, "stop");
+    lifecycle.register(`${name}:drain`, async () => {
+      await draining;
+      await Promise.allSettled([...active]);
+    }, "drain");
+    lifecycle.register(`${name}:force`, () => server.stop(true), "force");
+  }
+  return server;
 }
 // ../../src/bootstrap/web/session.ts
 import { createHmac, randomBytes } from "crypto";
@@ -1944,8 +2314,10 @@ export {
   DATABASE_URL_CONFIG_KEY,
   DEFAULT_APP_PORT,
   REDIS_URL_CONFIG_KEY,
+  RedisSchedulerLeaseStore,
   RouteRegistry,
   Schedule,
+  SchedulerLeaseLostError,
   ServiceContainer,
   appSchedule,
   assertAppDependenciesComplete,
@@ -1957,6 +2329,7 @@ export {
   checkRedis,
   collectProviders,
   configureModulesDirectory,
+  configureModulesManifest,
   coreProviders,
   createAppContext,
   createAppDependencies,
@@ -1969,6 +2342,7 @@ export {
   createWebServer,
   discoverJobs,
   discoverModelTableNames,
+  discoverModels,
   discoverModules,
   ensureModulesLoaded,
   getRequiredDependency,
@@ -1997,6 +2371,7 @@ export {
   setActiveApplicationContext,
   slugify,
   toRouteRequest,
+  tracing_default as tracingProvider,
   wrapSecuredRouteModelByKey,
   wrapWebLogin,
   wrapWebRegister