@holo-js/core 0.2.6 → 0.3.1

package/dist/{chunk-H43SANQQ.mjs → chunk-34VBLRNF.mjs}

@@ -12,7 +12,7 @@ import {
 // src/portable/registry.ts
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { DEFAULT_HOLO_PROJECT_PATHS } from "@holo-js/db";
+import { DEFAULT_HOLO_PROJECT_PATHS } from "@holo-js/kernel";
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -118,11 +118,31 @@ var registryInternals = {
   normalizeLegacyGeneratedProjectRegistry
 };
 
+// src/portable/renderingRuntime.ts
+function getHoloRenderingRuntime() {
+  const runtime = globalThis;
+  runtime.__holoRenderingRuntime__ ??= {};
+  return runtime.__holoRenderingRuntime__;
+}
+function configureHoloRenderingRuntime(bindings) {
+  getHoloRenderingRuntime().renderView = bindings?.renderView;
+}
+function resetHoloRenderingRuntime() {
+  getHoloRenderingRuntime().renderView = void 0;
+}
+function restoreHoloRenderingRuntime(renderView) {
+  if (renderView) {
+    configureHoloRenderingRuntime({ renderView });
+    return;
+  }
+  resetHoloRenderingRuntime();
+}
+
 // src/portable/holo.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { createHash, createHmac } from "node:crypto";
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve5 } from "node:path";
+import { createRuntimeLifecycle } from "@holo-js/kernel";
 import {
   config as globalConfig,
   configureConfigRuntime,
@@ -132,10 +152,13 @@ import {
   useConfig as globalUseConfig
 } from "@holo-js/config";
 import {
+  connectionAsyncContext,
   configureDB,
-  DB,
+  DB as DB2,
   Entity,
-  resetDB
+  registerDatabaseDriverFactory,
+  resetDB,
+  unregisterDatabaseDriverFactory
 } from "@holo-js/db";
 
 // src/runtimeModule.ts
@@ -156,14 +179,18 @@ async function importModule(specifier) {
   );
 }
 var runtimeModuleRequire = createRequire(import.meta.url);
+function resolveRuntimeModuleSearchPaths(projectRoot, runtimeModuleUrl = import.meta.url) {
+  const runtimeModulePath = normalizeImportTarget(runtimeModuleUrl);
+  return runtimeModulePath.includes("/node_modules/@holo-js/core/") ? void 0 : [projectRoot];
+}
 function resolveOptionalImportSpecifier(specifier, projectRoot) {
   if (!projectRoot) {
     return specifier;
   }
   try {
-    return pathToFileURL(runtimeModuleRequire.resolve(specifier, {
-      paths: [projectRoot]
-    })).href;
+    const paths = resolveRuntimeModuleSearchPaths(projectRoot);
+    const resolved = paths ? runtimeModuleRequire.resolve(specifier, { paths: [...paths] }) : runtimeModuleRequire.resolve(specifier);
+    return pathToFileURL(resolved).href;
   } catch {
     return specifier;
   }
@@ -181,6 +208,16 @@ function normalizeImportSpecifier(specifier) {
 function normalizeImportTarget(value) {
   return normalizeImportSpecifier(value).replace(/\\/g, "/");
 }
+function resolvePackageRootSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, packageName] = specifier.split("/");
+    return scope && packageName ? `${scope}/${packageName}` : void 0;
+  }
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.includes(":")) {
+    return void 0;
+  }
+  return specifier.split("/")[0];
+}
 function matchesRelativeImportTarget(failedTarget, specifier) {
   if (!failedTarget || !specifier.startsWith(".")) {
     return false;
@@ -200,6 +237,10 @@ function isMissingOptionalModule(error, specifier, resolvedSpecifier) {
     normalizeImportTarget(specifier),
     normalizeImportTarget(resolvedSpecifier)
   ]);
+  const packageRootSpecifier = resolvePackageRootSpecifier(specifier);
+  if (packageRootSpecifier) {
+    expectedTargets.add(packageRootSpecifier);
+  }
   const normalizedFailedTarget = typeof failedTarget === "string" ? normalizeImportTarget(failedTarget) : void 0;
   const matchesRequestedTarget = typeof normalizedFailedTarget === "string" && (expectedTargets.has(normalizedFailedTarget) || matchesRelativeImportTarget(normalizedFailedTarget, specifier));
   return "code" in error && error.code === "ERR_MODULE_NOT_FOUND" && matchesRequestedTarget || message.startsWith("Cannot find package '") && matchesRequestedTarget || message.startsWith("Cannot find module '") && matchesRequestedTarget || message.includes("Does the file exist?") && message.startsWith("Failed to load url ") && matchesRequestedTarget || message.startsWith('Could not resolve "') && matchesRequestedTarget;
@@ -317,8 +358,10 @@ var runtimeModuleInternals = {
   bundleRuntimeModule,
   importModule,
   importOptionalRuntimeModule,
+  isMissingOptionalModule,
   loadEsbuild,
   pathExists,
+  resolveRuntimeModuleSearchPaths,
   runEsbuild,
   writeLoaderTsconfig
 };
@@ -326,8 +369,8 @@ var runtimeModuleInternals = {
 // src/storageRuntime.ts
 import { mkdir as mkdir2, readFile as readFile2, readdir, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, isAbsolute, join as join2, relative, resolve as resolve2, sep, win32 } from "node:path";
-async function importOptionalModule(specifier) {
-  return importOptionalRuntimeModule(specifier);
+async function importOptionalModule(specifier, projectRoot) {
+  return importOptionalRuntimeModule(specifier, projectRoot ? { projectRoot } : {});
 }
 function resolveStorageKeyPath(root, key) {
   if (isAbsolute(key) || win32.isAbsolute(key)) {
@@ -427,8 +470,8 @@ function createFileStorageBackend(root) {
     }
   };
 }
-async function createS3StorageBackend(disk) {
-  const storageS3 = await importOptionalModule("@holo-js/storage/runtime/drivers/s3");
+async function createS3StorageBackend(projectRoot, disk) {
+  const storageS3 = await importOptionalModule("@holo-js/storage-s3", projectRoot);
   if (!storageS3) {
     throw new Error("[@holo-js/core] Storage config references an s3 disk but @holo-js/storage-s3 is not installed.");
   }
@@ -455,7 +498,7 @@ async function configurePlainNodeStorageRuntime(projectRoot, loadedConfig) {
   });
   const backends = /* @__PURE__ */ new Map();
   for (const [diskName, disk] of Object.entries(normalizedStorage.disks)) {
-    const backend = disk.driver === "s3" ? await createS3StorageBackend(disk) : createFileStorageBackend(resolve2(projectRoot, disk.root));
+    const backend = disk.driver === "s3" ? await createS3StorageBackend(projectRoot, disk) : createFileStorageBackend(resolve2(projectRoot, disk.root));
     backends.set(diskName, backend);
   }
   storageRuntime.configureStorageRuntime({
@@ -481,150 +524,231 @@ var storageRuntimeInternals = {
   importOptionalModule
 };
 
-// src/portable/holo.ts
+// src/portable/discoveryRuntime.ts
+import { existsSync } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 async function preloadGeneratedSchemaModule(projectRoot, registry) {
   const entry = registry?.paths.generatedSchema;
-  if (!entry) {
-    return;
-  }
+  if (!entry) return;
   const expectedTarget = resolve3(projectRoot, entry);
-  if (!existsSync(expectedTarget)) {
-    return;
-  }
+  if (!existsSync(expectedTarget)) return;
   try {
     await importBundledRuntimeModule(projectRoot, entry);
   } catch (error) {
     if (error instanceof Error && /Cannot find module|ERR_MODULE_NOT_FOUND|MODULE_NOT_FOUND|Failed to load url|Failed to load /.test(error.message)) {
-      const message = error.message;
-      const failedTarget = message.match(/Cannot find module '([^']+)'|Cannot find package '([^']+)'|Failed to load url ([^ ]+)|Failed to load ([^ ]+)\./)?.slice(1).find((value) => typeof value === "string");
-      if (failedTarget === expectedTarget) {
-        return;
-      }
+      const failedTarget = error.message.match(/Cannot find module '([^']+)'|Cannot find package '([^']+)'|Failed to load url ([^ ]+)|Failed to load ([^ ]+)\./)?.slice(1).find((value) => typeof value === "string");
+      if (failedTarget === expectedTarget) return;
     }
     throw error;
   }
 }
 async function preloadDiscoveredModelModules(projectRoot, registry) {
-  if (!registry || registry.models.length === 0) {
-    return;
-  }
+  if (!registry || registry.models.length === 0) return;
   for (const entry of registry.models) {
     const sourcePath = resolve3(projectRoot, entry.sourcePath);
-    if (!existsSync(sourcePath)) {
-      continue;
-    }
-    await importBundledRuntimeModule(projectRoot, sourcePath);
+    if (existsSync(sourcePath)) await importBundledRuntimeModule(projectRoot, sourcePath);
   }
 }
-function closeSessionRedisAdapter(adapter) {
-  return adapter.disconnect?.() || adapter.close?.();
+
+// src/portable/configRuntime.ts
+var featureConfigContributionSpecifiers = [
+  "@holo-js/auth/config",
+  "@holo-js/broadcast/config",
+  "@holo-js/cache/config",
+  "@holo-js/mail/config",
+  "@holo-js/media/config",
+  "@holo-js/notifications/config",
+  "@holo-js/queue/config",
+  "@holo-js/security/config",
+  "@holo-js/session/config",
+  "@holo-js/storage/config"
+];
+async function loadDirectFeatureConfigContribution(specifier) {
+  switch (specifier) {
+    case "@holo-js/auth/config":
+      await import("@holo-js/auth/config");
+      break;
+    case "@holo-js/broadcast/config":
+      await import("@holo-js/broadcast/config");
+      break;
+    case "@holo-js/cache/config":
+      await import("@holo-js/cache/config");
+      break;
+    case "@holo-js/mail/config":
+      await import("@holo-js/mail/config");
+      break;
+    case "@holo-js/media/config":
+      await import("@holo-js/media/config");
+      break;
+    case "@holo-js/notifications/config":
+      await import("@holo-js/notifications/config");
+      break;
+    case "@holo-js/queue/config":
+      await import("@holo-js/queue/config");
+      break;
+    case "@holo-js/security/config":
+      await import("@holo-js/security/config");
+      break;
+    case "@holo-js/session/config":
+      await import("@holo-js/session/config");
+      break;
+    case "@holo-js/storage/config":
+      await import("@holo-js/storage/config");
+      break;
+  }
+}
+var defaultLoaders = {
+  loadDirect: loadDirectFeatureConfigContribution,
+  async loadOptional(specifier, projectRoot) {
+    return await importOptionalRuntimeModule(specifier, { projectRoot });
+  }
+};
+async function loadInstalledFeatureConfigContributions(projectRoot, loaders = defaultLoaders) {
+  for (const specifier of featureConfigContributionSpecifiers) {
+    try {
+      await loaders.loadDirect(specifier);
+    } catch {
+      const loaded = await loaders.loadOptional(specifier, projectRoot);
+      if (!loaded) continue;
+    }
+  }
 }
-var CORE_BROADCAST_PUBLISHER_MARKER = /* @__PURE__ */ Symbol.for("holo-js.core.broadcast.publisher");
-var frameworkBuildEnvKey = "HOLO_INTERNAL_FRAMEWORK_BUILD";
-function shouldBootRuntimeServices(processEnv = process.env) {
-  return processEnv[frameworkBuildEnvKey] !== "1";
+
+// src/portable/authPersistence.ts
+function normalizeDateValue(value) {
+  return value instanceof Date ? value : new Date(String(value));
 }
-function getRuntimeState() {
-  const runtime = globalThis;
-  runtime.__holoRuntime__ ??= {};
-  return runtime.__holoRuntime__;
+function normalizeJsonValue(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
 }
-function configureHoloRenderingRuntime(bindings) {
-  getRuntimeState().renderView = bindings?.renderView;
+function normalizeStoredUserId(value) {
+  return typeof value === "number" ? value : String(value);
 }
-function resetHoloRenderingRuntime() {
-  getRuntimeState().renderView = void 0;
+function normalizeAccessTokenRecord(row) {
+  const abilities = normalizeJsonValue(row.abilities);
+  return Object.freeze({
+    id: String(row.id),
+    provider: String(row.provider),
+    userId: normalizeStoredUserId(row.user_id),
+    name: String(row.name),
+    abilities: Array.isArray(abilities) ? Object.freeze([...abilities]) : Object.freeze([]),
+    tokenHash: String(row.token_hash),
+    createdAt: normalizeDateValue(row.created_at),
+    lastUsedAt: row.last_used_at ? normalizeDateValue(row.last_used_at) : void 0,
+    expiresAt: row.expires_at ? normalizeDateValue(row.expires_at) : null
+  });
 }
-function restoreHoloRenderingRuntime(renderView) {
-  if (renderView) {
-    configureHoloRenderingRuntime({
-      renderView
-    });
-    return;
-  }
-  resetHoloRenderingRuntime();
+function serializeAccessTokenRecord(record) {
+  return {
+    id: record.id,
+    provider: record.provider,
+    user_id: String(record.userId),
+    name: record.name,
+    abilities: JSON.stringify(record.abilities),
+    token_hash: record.tokenHash,
+    created_at: record.createdAt.toISOString(),
+    last_used_at: record.lastUsedAt?.toISOString() ?? null,
+    expires_at: record.expiresAt?.toISOString() ?? null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-function snapshotOptionalSubsystemRuntimeBindings() {
-  const state = getRuntimeState();
-  const runtime = globalThis;
+function normalizeEmailVerificationTokenRecord(row) {
   return Object.freeze({
-    ...runtime.__holoMailRuntime__?.bindings ? { mail: runtime.__holoMailRuntime__.bindings } : {},
-    ...runtime.__holoNotificationsRuntime__?.bindings ? { notifications: runtime.__holoNotificationsRuntime__.bindings } : {},
-    ...runtime.__holoBroadcastRuntime__?.bindings ? { broadcast: runtime.__holoBroadcastRuntime__.bindings } : {},
-    /* v8 ignore start -- this snapshot branch only applies when restoring externally managed session adapters across runtime swaps */
-    ...state.sessionRedisAdapters ? {
-      session: Object.freeze({
-        sessionRedisAdapters: state.sessionRedisAdapters
-      })
-    } : {},
-    /* v8 ignore stop */
-    ...runtime.__holoSecurityRuntime__?.bindings || state.securityRedisAdapter || typeof state.securityRateLimitStoreManaged !== "undefined" ? {
-      security: Object.freeze({
-        ...runtime.__holoSecurityRuntime__?.bindings ? { bindings: runtime.__holoSecurityRuntime__.bindings } : {},
-        ...state.securityRedisAdapter ? { securityRedisAdapter: state.securityRedisAdapter } : {},
-        ...typeof state.securityRateLimitStoreManaged !== "undefined" ? { securityRateLimitStoreManaged: state.securityRateLimitStoreManaged } : {}
-      })
-    } : {}
+    id: String(row.id),
+    provider: String(row.provider),
+    userId: normalizeStoredUserId(row.user_id),
+    email: String(row.email),
+    tokenHash: String(row.token_hash),
+    createdAt: normalizeDateValue(row.created_at),
+    expiresAt: normalizeDateValue(row.expires_at)
   });
 }
-function restoreOptionalSubsystemRuntimeBindings(bindings) {
-  const state = getRuntimeState();
-  const runtime = globalThis;
-  if (bindings.mail || runtime.__holoMailRuntime__) {
-    runtime.__holoMailRuntime__ ??= {};
-    runtime.__holoMailRuntime__.bindings = bindings.mail;
-  }
-  if (bindings.notifications || runtime.__holoNotificationsRuntime__) {
-    runtime.__holoNotificationsRuntime__ ??= {};
-    runtime.__holoNotificationsRuntime__.bindings = bindings.notifications;
-  }
-  if (bindings.broadcast || runtime.__holoBroadcastRuntime__) {
-    runtime.__holoBroadcastRuntime__ ??= {};
-    runtime.__holoBroadcastRuntime__.bindings = bindings.broadcast;
-  }
-  state.sessionRedisAdapters = bindings.session?.sessionRedisAdapters;
-  if (bindings.security || runtime.__holoSecurityRuntime__) {
-    runtime.__holoSecurityRuntime__ ??= {};
-    runtime.__holoSecurityRuntime__.bindings = bindings.security?.bindings;
-    state.securityRedisAdapter = bindings.security?.securityRedisAdapter;
-    state.securityRateLimitStoreManaged = bindings.security?.securityRateLimitStoreManaged;
-  }
-}
-var BROADCAST_PUBLISH_TIMEOUT_MS = 1e4;
-async function importOptionalModule2(specifier, options = {}) {
-  return importOptionalRuntimeModule(specifier, options);
+function serializeEmailVerificationTokenRecord(record) {
+  return {
+    id: record.id,
+    provider: record.provider,
+    user_id: String(record.userId),
+    email: record.email,
+    token_hash: record.tokenHash,
+    created_at: record.createdAt.toISOString(),
+    expires_at: record.expiresAt.toISOString(),
+    used_at: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-var portableRuntimeModuleInternals = {
-  importOptionalModule: importOptionalModule2
-};
-function hasLoadedConfigFile(loadedConfig, configName) {
-  return loadedConfig.loadedFiles.some((filePath) => {
-    const normalizedPath = filePath.replaceAll("\\", "/");
-    return normalizedPath.endsWith(`/config/${configName}.ts`) || normalizedPath.endsWith(`/config/${configName}.mts`) || normalizedPath.endsWith(`/config/${configName}.js`) || normalizedPath.endsWith(`/config/${configName}.mjs`) || normalizedPath.endsWith(`/config/${configName}.cts`) || normalizedPath.endsWith(`/config/${configName}.cjs`);
+function normalizePasswordResetTokenRecord(row) {
+  return Object.freeze({
+    id: String(row.id),
+    provider: typeof row.provider === "string" ? row.provider : "users",
+    email: String(row.email),
+    table: typeof row.__holo_table === "string" ? row.__holo_table : void 0,
+    tokenHash: String(row.token_hash),
+    createdAt: normalizeDateValue(row.created_at),
+    expiresAt: normalizeDateValue(row.expires_at)
   });
 }
-function queueConfigUsesDatabaseDriver(loadedConfig) {
-  return Object.values(loadedConfig.queue.connections).some((connection) => connection.driver === "database");
+function serializePasswordResetTokenRecord(record) {
+  return {
+    id: record.id,
+    provider: record.provider,
+    email: record.email,
+    token_hash: record.tokenHash,
+    created_at: record.createdAt.toISOString(),
+    expires_at: record.expiresAt.toISOString(),
+    used_at: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-function queueConfigUsesDatabaseBackedFailedStore(loadedConfig) {
-  return loadedConfig.queue.failed !== false;
+
+// src/portable/pluginRuntime.ts
+import { resolve as resolve4 } from "node:path";
+import {
+  loadHoloPluginBootModules,
+  loadHoloPluginDefinitions
+} from "@holo-js/kernel";
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function registryHasJobs(registry) {
-  return (registry?.jobs.length ?? 0) > 0;
+var bootedHoloPluginModules = /* @__PURE__ */ new Set();
+function resolveHoloPluginBootKey(projectRoot, bootModule) {
+  return [resolve4(projectRoot), bootModule.plugin.packageName, bootModule.runtime].join("\0");
 }
-function registryHasEvents(registry) {
-  return (registry?.events.length ?? 0) > 0 || (registry?.listeners.length ?? 0) > 0;
+function resolveLoadedPluginNames(loadedConfig) {
+  return loadedConfig.app.plugins;
 }
-function authConfigUsesSocialProviders(loadedConfig) {
-  return Object.keys(loadedConfig.auth.social).length > 0;
+async function bootConfiguredHoloPluginModule(projectRoot, loadedConfig, bootModule) {
+  const bootKey = resolveHoloPluginBootKey(projectRoot, bootModule);
+  if (bootedHoloPluginModules.has(bootKey)) return;
+  const candidate = isRecord2(bootModule.module) && typeof bootModule.module.default !== "undefined" ? bootModule.module.default : bootModule.module;
+  if (typeof candidate !== "function") return;
+  await candidate({ projectRoot, config: loadedConfig });
+  bootedHoloPluginModules.add(bootKey);
 }
-function authConfigUsesWorkosProviders(loadedConfig) {
-  return Object.entries(loadedConfig.auth.workos).some(([name, provider]) => name !== "provider" && name !== "identityStore" && typeof provider === "object" && provider !== null);
+function resetBootedHoloPluginModules() {
+  bootedHoloPluginModules.clear();
 }
-function authConfigUsesClerkProviders(loadedConfig) {
-  return Object.entries(loadedConfig.auth.clerk).some(([name, provider]) => name !== "provider" && name !== "identityStore" && typeof provider === "object" && provider !== null);
+async function loadConfiguredHoloPluginDefinitions(projectRoot, pluginNames) {
+  const normalizedNames = [...new Set(pluginNames.map((name) => name.trim()).filter(Boolean))];
+  return loadHoloPluginDefinitions(projectRoot, normalizedNames, { moduleVersion: String(Date.now()) });
 }
-var HOLO_AUTH_PROVIDER_MARKER = /* @__PURE__ */ Symbol.for("holo-js.auth.provider");
+async function loadConfiguredHoloPluginBootModules(projectRoot, plugins) {
+  return loadHoloPluginBootModules(projectRoot, plugins, { moduleVersion: String(Date.now()) });
+}
+function mergeQueueRuntimeDriverFactories(...sources) {
+  const factories = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    for (const factory of source ?? []) factories.set(factory.driver, factory);
+  }
+  return Object.freeze([...factories.values()]);
+}
+
+// src/portable/authRequestContext.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 function attachAuthRequestAccessors(context, accessors) {
   return Object.freeze({
     ...context,
@@ -656,141 +780,503 @@ function createRequestAwareAuthContext(context, accessors) {
       return resolveRequestContext().redirectResponse?.(url, status);
     },
     setRequestAccessors(nextAccessors) {
-      requestAccessorStorage.enterWith({
-        accessors: nextAccessors
-      });
+      requestAccessorStorage.enterWith({ accessors: nextAccessors });
     },
-    async runWithRequestAccessors(nextAccessors, callback) {
-      return await requestAccessorStorage.run({
-        accessors: nextAccessors
-      }, callback);
+    runWithRequestAccessors(nextAccessors, callback) {
+      return requestAccessorStorage.run(
+        { accessors: nextAccessors },
+        () => context.run ? context.run(callback) : callback()
+      );
     }
   });
 }
-async function loadQueueModule(required = false) {
-  const queueModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/queue");
-  if (!queueModule && required) {
-    throw new Error("[@holo-js/core] Queue support requires @holo-js/queue to be installed.");
-  }
-  return queueModule;
-}
-async function loadQueueDbModule() {
-  return portableRuntimeModuleInternals.importOptionalModule("@holo-js/queue-db");
+
+// src/portable/recordPersistence.ts
+function normalizeDateLike(value) {
+  return value instanceof Date ? value : new Date(String(value));
 }
-async function loadCacheModule(required = false, projectRoot) {
-  const cacheModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/cache", {
-    projectRoot
+function normalizeSessionRecordFromRow(row) {
+  const decodedData = (() => {
+    if (row.data && typeof row.data === "object") return row.data;
+    if (typeof row.data !== "string") return {};
+    try {
+      const parsed = JSON.parse(row.data);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  })();
+  return Object.freeze({
+    id: String(row.id),
+    store: typeof row.store === "string" ? row.store : "database",
+    data: Object.freeze(decodedData),
+    createdAt: normalizeDateLike(row.created_at),
+    lastActivityAt: normalizeDateLike(row.last_activity_at),
+    expiresAt: normalizeDateLike(row.expires_at),
+    rememberTokenHash: typeof row.remember_token_hash === "string" ? row.remember_token_hash : void 0
   });
-  if (!cacheModule && required) {
-    throw new Error("[@holo-js/core] Cache support requires @holo-js/cache to be installed.");
-  }
-  return cacheModule;
-}
-function resetCacheRuntimeGlobalsFallback() {
-  const runtime = globalThis;
-  if (runtime.__holoCacheRuntime__) {
-    runtime.__holoCacheRuntime__.bindings = void 0;
-  }
-  if (runtime.__holoCacheQueryBridge__) {
-    runtime.__holoCacheQueryBridge__.dependencyIndex = void 0;
-  }
-  if (runtime.__holoDbQueryCacheBridge__) {
-    runtime.__holoDbQueryCacheBridge__.bridge = void 0;
-  }
-}
-async function loadEventsModule(required = false) {
-  const eventsModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/events");
-  if (!eventsModule && required) {
-    throw new Error("[@holo-js/core] Events support requires @holo-js/events to be installed.");
-  }
-  return eventsModule;
-}
-async function loadSessionModule(required = false) {
-  const sessionModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/session");
-  if (!sessionModule && required) {
-    throw new Error("[@holo-js/core] Session support requires @holo-js/session to be installed.");
-  }
-  return sessionModule;
-}
-async function loadSecurityModule(required = false) {
-  const securityModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/security");
-  if (!securityModule && required) {
-    throw new Error("[@holo-js/core] Security support requires @holo-js/security to be installed.");
-  }
-  return securityModule;
-}
-async function loadSecurityRedisAdapterModule(required = false) {
-  const securityRedisAdapterModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/security/drivers/redis-adapter");
-  if (!securityRedisAdapterModule && required) {
-    throw new Error("[@holo-js/core] Redis-backed security rate limits require @holo-js/security/drivers/redis-adapter to be installed.");
-  }
-  return securityRedisAdapterModule;
-}
-async function loadSessionRedisAdapterModule(required = false) {
-  const sessionRedisAdapterModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/session/drivers/redis-adapter");
-  if (!sessionRedisAdapterModule && required) {
-    throw new Error("[@holo-js/core] Redis-backed session stores require @holo-js/session/drivers/redis-adapter to be installed.");
-  }
-  return sessionRedisAdapterModule;
 }
-async function loadNotificationsModule(required = false) {
-  const notificationsModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/notifications");
-  if (!notificationsModule && required) {
-    throw new Error("[@holo-js/core] Notifications support requires @holo-js/notifications to be installed.");
-  }
-  return notificationsModule;
+function serializeSessionRecordForRow(record) {
+  return {
+    id: record.id,
+    store: record.store,
+    data: JSON.stringify(record.data ?? {}),
+    created_at: record.createdAt.toISOString(),
+    last_activity_at: record.lastActivityAt.toISOString(),
+    expires_at: record.expiresAt.toISOString(),
+    invalidated_at: null,
+    remember_token_hash: record.rememberTokenHash ?? null
+  };
 }
-async function loadBroadcastModule(required = false, projectRoot) {
-  const broadcastModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/broadcast", {
-    projectRoot
+function normalizeNotificationRecordFromRow(row) {
+  const decodedData = normalizeJsonValue(row.data);
+  return Object.freeze({
+    id: String(row.id),
+    type: typeof row.type === "string" ? row.type : void 0,
+    notifiableType: String(row.notifiable_type),
+    notifiableId: typeof row.notifiable_id === "number" ? row.notifiable_id : String(row.notifiable_id),
+    data: decodedData,
+    readAt: row.read_at ? normalizeDateLike(row.read_at) : null,
+    createdAt: normalizeDateLike(row.created_at),
+    updatedAt: normalizeDateLike(row.updated_at)
   });
-  if (!broadcastModule && required) {
-    throw new Error("[@holo-js/core] Broadcast support requires @holo-js/broadcast to be installed.");
-  }
-  return broadcastModule;
-}
-async function loadMailModule(required = false) {
-  const mailModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/mail");
-  if (!mailModule && required) {
-    throw new Error("[@holo-js/core] Mail support requires @holo-js/mail to be installed.");
-  }
-  return mailModule;
 }
-async function loadAuthModule(required = false) {
-  const authModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/auth");
-  if (!authModule && required) {
-    throw new Error("[@holo-js/core] Auth support requires @holo-js/auth to be installed.");
-  }
-  return authModule;
-}
-async function loadAuthorizationModule(required = false) {
-  const authorizationModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/authorization");
-  if (!authorizationModule && required) {
-    throw new Error("[@holo-js/core] Authorization support requires @holo-js/authorization to be installed.");
-  }
-  return authorizationModule;
-}
-async function loadSocialModule(required = false) {
-  const socialModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/auth-social");
-  if (!socialModule && required) {
-    throw new Error("[@holo-js/core] Social auth config requires @holo-js/auth-social to be installed.");
-  }
-  return socialModule;
-}
-async function loadWorkosModule(required = false) {
-  const workosModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/auth-workos");
-  if (!workosModule && required) {
-    throw new Error("[@holo-js/core] WorkOS auth config requires @holo-js/auth-workos to be installed.");
-  }
-  return workosModule;
+function serializeNotificationRecordForRow(record) {
+  return {
+    id: record.id,
+    type: record.type ?? null,
+    notifiable_type: record.notifiableType,
+    notifiable_id: String(record.notifiableId),
+    data: JSON.stringify(record.data ?? null),
+    read_at: record.readAt ? record.readAt.toISOString() : null,
+    created_at: record.createdAt.toISOString(),
+    updated_at: record.updatedAt.toISOString()
+  };
+}
+
+// src/portable/notificationPersistence.ts
+import { DB } from "@holo-js/db";
+function createCoreNotificationStore(loadedConfig) {
+  const tableName = loadedConfig.notifications.table;
+  const connectionName = loadedConfig.database.defaultConnection;
+  return Object.freeze({
+    async create(record) {
+      await DB.table(tableName, connectionName).insert(serializeNotificationRecordForRow(record));
+    },
+    async list(notifiable) {
+      const rows = await DB.table(tableName, connectionName).where("notifiable_type", notifiable.type).where("notifiable_id", String(notifiable.id)).orderBy("created_at", "desc").get();
+      return Object.freeze(rows.map((row) => normalizeNotificationRecordFromRow(row)));
+    },
+    async unread(notifiable) {
+      const rows = await DB.table(tableName, connectionName).where("notifiable_type", notifiable.type).where("notifiable_id", String(notifiable.id)).whereNull("read_at").orderBy("created_at", "desc").get();
+      return Object.freeze(rows.map((row) => normalizeNotificationRecordFromRow(row)));
+    },
+    async markAsRead(ids) {
+      if (ids.length === 0) return 0;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await DB.table(tableName, connectionName).whereIn("id", ids).update({ read_at: now, updated_at: now });
+      return result.affectedRows ?? 0;
+    },
+    async markAsUnread(ids) {
+      if (ids.length === 0) return 0;
+      const result = await DB.table(tableName, connectionName).whereIn("id", ids).update({ read_at: null, updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+      return result.affectedRows ?? 0;
+    },
+    async delete(ids) {
+      if (ids.length === 0) return 0;
+      const result = await DB.table(tableName, connectionName).whereIn("id", ids).delete();
+      return result.affectedRows ?? 0;
+    }
+  });
+}
+
+// src/portable/authMailDelivery.ts
+var authEmailDateFormatter = new Intl.DateTimeFormat("en-US", {
+  dateStyle: "long",
+  timeStyle: "short",
+  timeZone: "UTC"
+});
+function formatAuthEmailExpiration(expiresAt) {
+  return `${authEmailDateFormatter.format(expiresAt)} UTC`;
+}
+function escapeAuthEmailHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function createNotificationMailText(message) {
+  const parts = [
+    typeof message.greeting === "string" ? message.greeting.trim() : void 0,
+    ...(message.lines ?? []).map((line) => line.trim()).filter(Boolean),
+    message.action ? `${message.action.label}: ${message.action.url}` : void 0
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function createNotificationMailHtml(message) {
+  const greeting = typeof message.greeting === "string" ? message.greeting.trim() : void 0;
+  const lines = (message.lines ?? []).map((line) => line.trim()).filter(Boolean);
+  const sections = [
+    greeting ? `<p style="margin:0 0 16px;">${escapeAuthEmailHtml(greeting)}</p>` : "",
+    ...lines.map((line) => `<p style="margin:0 0 16px;">${escapeAuthEmailHtml(line)}</p>`),
+    message.action ? `<p style="margin:24px 0;"><a href="${escapeAuthEmailHtml(message.action.url)}" style="display:inline-block;padding:12px 18px;background:#111827;color:#ffffff;text-decoration:none;border-radius:8px;font-weight:600;">${escapeAuthEmailHtml(message.action.label)}</a></p>` : "",
+    message.action ? `<p style="margin:0;color:#475569;font-size:14px;">If the button does not work, open this link: <a href="${escapeAuthEmailHtml(message.action.url)}">${escapeAuthEmailHtml(message.action.url)}</a></p>` : ""
+  ].join("");
+  return [
+    "<!doctype html>",
+    '<html><head><meta charset="utf-8">',
+    `<title>${escapeAuthEmailHtml(message.subject)}</title>`,
+    '</head><body style="margin:0;padding:24px;font-family:Arial,sans-serif;color:#0f172a;background:#f8fafc;">',
+    '<div style="max-width:640px;margin:0 auto;background:#ffffff;border:1px solid #e2e8f0;border-radius:12px;padding:32px;">',
+    `<h1 style="margin:0 0 24px;font-size:24px;line-height:1.3;">${escapeAuthEmailHtml(message.subject)}</h1>`,
+    sections,
+    "</div></body></html>"
+  ].join("");
+}
+function createAuthActionUrl(appUrl, path, token) {
+  const normalizedBaseUrl = appUrl.endsWith("/") ? appUrl.slice(0, -1) : appUrl;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${normalizedBaseUrl}${normalizedPath}`);
+  url.searchParams.set("token", token);
+  return url.toString();
+}
+function createAuthEmailHtml(message) {
+  return createNotificationMailHtml(message);
+}
+function createCoreNotificationMailSender(mailModule) {
+  return Object.freeze({
+    async send(message, context) {
+      if (!context.route) {
+        throw new Error("[@holo-js/core] Email notifications require a resolved email route before bridging into mail.");
+      }
+      const fallbackText = createNotificationMailText(message);
+      await mailModule.sendMail({
+        to: context.route,
+        subject: message.subject,
+        html: typeof message.html === "string" ? message.html : createNotificationMailHtml(message),
+        ...typeof (message.text ?? fallbackText) === "string" ? { text: message.text ?? fallbackText } : {},
+        ...message.metadata ? { metadata: message.metadata } : {}
+      });
+    }
+  });
+}
+function createAuthMailDeliveryHook(mailModule, appUrl) {
+  return Object.freeze({
+    async sendEmailVerification(input) {
+      const recipientName = typeof input.user?.name === "string" ? input.user.name?.trim() : void 0;
+      const lines = [
+        "Confirm your account to finish signing in.",
+        `This verification link expires at ${formatAuthEmailExpiration(input.token.expiresAt)}.`
+      ];
+      const action = {
+        label: "Verify email address",
+        url: createAuthActionUrl(appUrl, input.route, input.token.plainTextToken)
+      };
+      await mailModule.sendMail({
+        to: { email: input.email, ...recipientName ? { name: recipientName } : {} },
+        subject: "Verify your email address",
+        html: createAuthEmailHtml({
+          subject: "Verify your email address",
+          ...recipientName ? { greeting: `Hello ${recipientName},` } : {},
+          lines,
+          action
+        }),
+        text: createNotificationMailText({
+          ...recipientName ? { greeting: `Hello ${recipientName},` } : {},
+          lines,
+          action
+        }),
+        metadata: { provider: input.provider, tokenId: input.token.id }
+      });
+    },
+    async sendPasswordReset(input) {
+      const lines = [
+        "Click the link below to choose a new password.",
+        `This reset link expires at ${formatAuthEmailExpiration(input.token.expiresAt)}.`
+      ];
+      const action = {
+        label: "Reset password",
+        url: createAuthActionUrl(appUrl, input.route, input.token.plainTextToken)
+      };
+      await mailModule.sendMail({
+        to: input.email,
+        subject: "Reset your password",
+        html: createAuthEmailHtml({ subject: "Reset your password", lines, action }),
+        text: createNotificationMailText({ lines, action }),
+        metadata: { provider: input.provider, tokenId: input.token.id }
+      });
+    }
+  });
+}
+
+// src/portable/optionalFeatureLoader.ts
+function createOptionalFeatureModuleLoader(importer, specifier, missingPackageMessage) {
+  async function load(required = false, options = {}) {
+    const module = await importer(specifier, options);
+    if (!module && required) throw new Error(missingPackageMessage);
+    return module;
+  }
+  return load;
+}
+
+// src/portable/featureDetection.ts
+function hasLoadedConfigFile(loadedConfig, configName) {
+  return loadedConfig.loadedFiles.some((filePath) => {
+    const normalizedPath = filePath.replaceAll("\\", "/");
+    return ["ts", "mts", "js", "mjs", "cts", "cjs"].some((extension) => normalizedPath.endsWith(`/config/${configName}.${extension}`));
+  });
+}
+function queueConfigUsesDatabaseDriver(loadedConfig) {
+  if (!loadedConfig.queue) return false;
+  return Object.values(loadedConfig.queue.connections).some((connection) => connection.driver === "database");
+}
+function queueConfigUsesRedisDriver(loadedConfig) {
+  if (!loadedConfig.queue) return false;
+  return Object.values(loadedConfig.queue.connections).some((connection) => connection.driver === "redis");
+}
+function queueConfigUsesDatabaseBackedFailedStore(loadedConfig) {
+  if (!loadedConfig.queue) return false;
+  return loadedConfig.queue.failed !== false;
+}
+function registryHasJobs(registry) {
+  return (registry?.jobs.length ?? 0) > 0;
+}
+function registryHasEvents(registry) {
+  return (registry?.events.length ?? 0) > 0 || (registry?.listeners.length ?? 0) > 0;
+}
+function authConfigUsesSocialProviders(loadedConfig) {
+  if (!loadedConfig.auth) return false;
+  return Object.keys(loadedConfig.auth.social).length > 0;
+}
+function authConfigUsesWorkosProviders(loadedConfig) {
+  if (!loadedConfig.auth) return false;
+  return Object.entries(loadedConfig.auth.workos).some(([name, provider]) => name !== "provider" && name !== "identityStore" && typeof provider === "object" && provider !== null);
+}
+function authConfigUsesClerkProviders(loadedConfig) {
+  if (!loadedConfig.auth) return false;
+  return Object.entries(loadedConfig.auth.clerk).some(([name, provider]) => name !== "provider" && name !== "identityStore" && typeof provider === "object" && provider !== null);
+}
+
+// src/portable/runtimeState.ts
+function createRuntimeStateAccessors() {
+  const getRuntimeState2 = () => {
+    const runtime = globalThis;
+    runtime.__holoRuntime__ ??= {};
+    return runtime.__holoRuntime__;
+  };
+  const snapshotOptionalSubsystemRuntimeBindings2 = () => {
+    const state = getRuntimeState2();
+    const runtime = globalThis;
+    return Object.freeze({
+      ...runtime.__holoMailRuntime__?.bindings ? { mail: runtime.__holoMailRuntime__.bindings } : {},
+      ...runtime.__holoNotificationsRuntime__?.bindings ? { notifications: runtime.__holoNotificationsRuntime__.bindings } : {},
+      ...runtime.__holoBroadcastRuntime__?.bindings ? { broadcast: runtime.__holoBroadcastRuntime__.bindings } : {},
+      ...state.sessionRedisAdapters ? { session: Object.freeze({ sessionRedisAdapters: state.sessionRedisAdapters }) } : {},
+      ...runtime.__holoSecurityRuntime__?.bindings || state.securityRedisAdapter || typeof state.securityRateLimitStoreManaged !== "undefined" ? {
+        security: Object.freeze({
+          ...runtime.__holoSecurityRuntime__?.bindings ? { bindings: runtime.__holoSecurityRuntime__.bindings } : {},
+          ...state.securityRedisAdapter ? { securityRedisAdapter: state.securityRedisAdapter } : {},
+          ...typeof state.securityRateLimitStoreManaged !== "undefined" ? { securityRateLimitStoreManaged: state.securityRateLimitStoreManaged } : {}
+        })
+      } : {}
+    });
+  };
+  const restoreOptionalSubsystemRuntimeBindings2 = (bindings) => {
+    const state = getRuntimeState2();
+    const runtime = globalThis;
+    if (bindings.mail || runtime.__holoMailRuntime__) {
+      runtime.__holoMailRuntime__ ??= {};
+      runtime.__holoMailRuntime__.bindings = bindings.mail;
+    }
+    if (bindings.notifications || runtime.__holoNotificationsRuntime__) {
+      runtime.__holoNotificationsRuntime__ ??= {};
+      runtime.__holoNotificationsRuntime__.bindings = bindings.notifications;
+    }
+    if (bindings.broadcast || runtime.__holoBroadcastRuntime__) {
+      runtime.__holoBroadcastRuntime__ ??= {};
+      runtime.__holoBroadcastRuntime__.bindings = bindings.broadcast;
+    }
+    state.sessionRedisAdapters = bindings.session?.sessionRedisAdapters;
+    if (bindings.security || runtime.__holoSecurityRuntime__) {
+      runtime.__holoSecurityRuntime__ ??= {};
+      runtime.__holoSecurityRuntime__.bindings = bindings.security?.bindings;
+      state.securityRedisAdapter = bindings.security?.securityRedisAdapter;
+      state.securityRateLimitStoreManaged = bindings.security?.securityRateLimitStoreManaged;
+    }
+  };
+  return {
+    getRuntimeState: getRuntimeState2,
+    restoreOptionalSubsystemRuntimeBindings: restoreOptionalSubsystemRuntimeBindings2,
+    snapshotOptionalSubsystemRuntimeBindings: snapshotOptionalSubsystemRuntimeBindings2
+  };
+}
+
+// src/portable/holo.ts
+function closeSessionRedisAdapter(adapter) {
+  return adapter.disconnect?.() || adapter.close?.();
+}
+var CORE_BROADCAST_PUBLISHER_MARKER = /* @__PURE__ */ Symbol.for("holo-js.core.broadcast.publisher");
+var frameworkBuildEnvKey = "HOLO_INTERNAL_FRAMEWORK_BUILD";
+function shouldBootRuntimeServices(processEnv = process.env) {
+  return processEnv[frameworkBuildEnvKey] !== "1";
+}
+var {
+  getRuntimeState,
+  restoreOptionalSubsystemRuntimeBindings,
+  snapshotOptionalSubsystemRuntimeBindings
+} = createRuntimeStateAccessors();
+var BROADCAST_PUBLISH_TIMEOUT_MS = 1e4;
+async function importOptionalModule2(specifier, options = {}) {
+  return importOptionalRuntimeModule(specifier, options);
+}
+var portableRuntimeModuleInternals = {
+  importOptionalModule: importOptionalModule2
+};
+var HOLO_AUTH_PROVIDER_MARKER = /* @__PURE__ */ Symbol.for("holo-js.auth.provider");
+var importOptionalFeature = (specifier, options) => portableRuntimeModuleInternals.importOptionalModule(specifier, options);
+var loadQueueModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/queue",
+  "[@holo-js/core] Queue support requires @holo-js/queue to be installed."
+);
+async function loadConfiguredDatabaseDrivers(projectRoot, loadedConfig) {
+  const packageByDriver = {
+    sqlite: { packageName: "@holo-js/db-sqlite", factoryExport: "sqliteDatabaseDriverFactory" },
+    postgres: { packageName: "@holo-js/db-postgres", factoryExport: "postgresDatabaseDriverFactory" },
+    mysql: { packageName: "@holo-js/db-mysql", factoryExport: "mysqlDatabaseDriverFactory" }
+  };
+  const drivers = new Set(Object.values(loadedConfig.database.connections).map((connection) => {
+    if (typeof connection === "string") {
+      if (connection.startsWith("postgres://") || connection.startsWith("postgresql://")) return "postgres";
+      if (connection.startsWith("mysql://") || connection.startsWith("mysql2://")) return "mysql";
+      return "sqlite";
+    }
+    return connection.driver ?? "sqlite";
+  }));
+  const factories = [];
+  for (const driver of drivers) {
+    const contribution = packageByDriver[driver];
+    const { packageName, factoryExport } = contribution;
+    const module = await portableRuntimeModuleInternals.importOptionalModule(packageName, { projectRoot });
+    if (!module) throw new Error(`[@holo-js/core] Database driver "${driver}" requires ${packageName} to be installed.`);
+    const factory = module[factoryExport];
+    if (!factory) throw new Error(`[@holo-js/core] Database driver package ${packageName} does not export ${factoryExport}.`);
+    factories.push(factory);
+  }
+  return factories;
+}
+async function loadQueueDbModule(projectRoot) {
+  return createOptionalFeatureModuleLoader(
+    importOptionalFeature,
+    "@holo-js/queue-db",
+    "[@holo-js/core] Database queues require @holo-js/queue-db to be installed."
+  )(false, { projectRoot });
+}
+async function loadQueueRedisModule(projectRoot) {
+  return createOptionalFeatureModuleLoader(
+    importOptionalFeature,
+    "@holo-js/queue-redis",
+    "[@holo-js/core] Redis queues require @holo-js/queue-redis to be installed."
+  )(false, { projectRoot });
+}
+async function loadCacheModule(required = false, projectRoot) {
+  const loader = createOptionalFeatureModuleLoader(
+    importOptionalFeature,
+    "@holo-js/cache",
+    "[@holo-js/core] Cache support requires @holo-js/cache to be installed."
+  );
+  return required ? loader(true, { projectRoot }) : loader(false, { projectRoot });
+}
+async function loadConfiguredCacheDrivers(projectRoot, cacheConfig) {
+  const packageByDriver = {
+    database: "@holo-js/cache-db",
+    redis: "@holo-js/cache-redis"
+  };
+  const drivers = new Set(Object.values(cacheConfig.drivers).map((driver) => driver.driver));
+  for (const driver of drivers) {
+    if (driver !== "database" && driver !== "redis") continue;
+    const packageName = packageByDriver[driver];
+    const module = await portableRuntimeModuleInternals.importOptionalModule(packageName, { projectRoot });
+    if (!module) throw new Error(`[@holo-js/core] Cache driver "${driver}" requires ${packageName} to be installed.`);
+  }
 }
-async function loadClerkModule(required = false) {
-  const clerkModule = await portableRuntimeModuleInternals.importOptionalModule("@holo-js/auth-clerk");
-  if (!clerkModule && required) {
-    throw new Error("[@holo-js/core] Clerk auth config requires @holo-js/auth-clerk to be installed.");
+function resetCacheRuntimeGlobalsFallback() {
+  const runtime = globalThis;
+  if (runtime.__holoCacheRuntime__) {
+    runtime.__holoCacheRuntime__.bindings = void 0;
+  }
+  if (runtime.__holoCacheQueryBridge__) {
+    runtime.__holoCacheQueryBridge__.dependencyIndex = void 0;
+  }
+  if (runtime.__holoDbQueryCacheBridge__) {
+    runtime.__holoDbQueryCacheBridge__.bridge = void 0;
   }
-  return clerkModule;
 }
+var loadEventsModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/events",
+  "[@holo-js/core] Events support requires @holo-js/events to be installed."
+);
+var loadSessionModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/session",
+  "[@holo-js/core] Session support requires @holo-js/session to be installed."
+);
+var loadSecurityModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/security",
+  "[@holo-js/core] Security support requires @holo-js/security to be installed."
+);
+var loadSecurityRedisAdapterModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/security/drivers/redis-adapter",
+  "[@holo-js/core] Redis-backed security rate limits require @holo-js/security/drivers/redis-adapter to be installed."
+);
+var loadSessionRedisAdapterModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/session/drivers/redis-adapter",
+  "[@holo-js/core] Redis-backed session stores require @holo-js/session/drivers/redis-adapter to be installed."
+);
+var loadNotificationsModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/notifications",
+  "[@holo-js/core] Notifications support requires @holo-js/notifications to be installed."
+);
+async function loadBroadcastModule(required = false, projectRoot) {
+  const loader = createOptionalFeatureModuleLoader(
+    importOptionalFeature,
+    "@holo-js/broadcast",
+    "[@holo-js/core] Broadcast support requires @holo-js/broadcast to be installed."
+  );
+  return required ? loader(true, { projectRoot }) : loader(false, { projectRoot });
+}
+var loadMailModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/mail",
+  "[@holo-js/core] Mail support requires @holo-js/mail to be installed."
+);
+var loadAuthModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/auth",
+  "[@holo-js/core] Auth support requires @holo-js/auth to be installed."
+);
+var loadAuthorizationModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/authorization",
+  "[@holo-js/core] Authorization support requires @holo-js/authorization to be installed."
+);
+var loadSocialModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/auth-social",
+  "[@holo-js/core] Social auth config requires @holo-js/auth-social to be installed."
+);
+var loadWorkosModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/auth-workos",
+  "[@holo-js/core] WorkOS auth config requires @holo-js/auth-workos to be installed."
+);
+var loadClerkModule = createOptionalFeatureModuleLoader(
+  importOptionalFeature,
+  "@holo-js/auth-clerk",
+  "[@holo-js/core] Clerk auth config requires @holo-js/auth-clerk to be installed."
+);
 function resolveQueueJobExport(queueModule, moduleValue) {
   const exports = moduleValue;
   if (queueModule.isQueueJobDefinition(exports.default)) {
@@ -831,74 +1317,7 @@ function resolveListenerExport(eventsModule, moduleValue) {
   return Object.values(exports).find((value) => hasListenerDefinitionMarker(value) || eventsModule.isListenerDefinition(value));
 }
 function resolveProjectRelativePath(projectRoot, value) {
-  return value.startsWith(".") || !value.startsWith("/") ? resolve3(projectRoot, value) : value;
-}
-function normalizeDateLike(value) {
-  return value instanceof Date ? value : new Date(String(value));
-}
-function normalizeSessionRecordFromRow(row) {
-  const decodedData = (() => {
-    if (row.data && typeof row.data === "object") {
-      return row.data;
-    }
-    if (typeof row.data === "string") {
-      try {
-        const parsed = JSON.parse(row.data);
-        return parsed && typeof parsed === "object" ? parsed : {};
-      } catch {
-        return {};
-      }
-    }
-    return {};
-  })();
-  return Object.freeze({
-    id: String(row.id),
-    /* v8 ignore next -- runtime rows usually carry an explicit store name; this preserves a safe default */
-    store: typeof row.store === "string" ? row.store : "database",
-    data: Object.freeze(decodedData),
-    createdAt: normalizeDateLike(row.created_at),
-    lastActivityAt: normalizeDateLike(row.last_activity_at),
-    expiresAt: normalizeDateLike(row.expires_at),
-    rememberTokenHash: typeof row.remember_token_hash === "string" ? row.remember_token_hash : void 0
-  });
-}
-function serializeSessionRecordForRow(record) {
-  return {
-    id: record.id,
-    store: record.store,
-    /* v8 ignore next -- record.data is always present in runtime flows; nullish fallback is purely defensive */
-    data: JSON.stringify(record.data ?? {}),
-    created_at: record.createdAt.toISOString(),
-    last_activity_at: record.lastActivityAt.toISOString(),
-    expires_at: record.expiresAt.toISOString(),
-    invalidated_at: null,
-    remember_token_hash: record.rememberTokenHash ?? null
-  };
-}
-function normalizeNotificationRecordFromRow(row) {
-  const decodedData = normalizeJsonValue(row.data);
-  return Object.freeze({
-    id: String(row.id),
-    type: typeof row.type === "string" ? row.type : void 0,
-    notifiableType: String(row.notifiable_type),
-    notifiableId: typeof row.notifiable_id === "number" ? row.notifiable_id : String(row.notifiable_id),
-    data: decodedData,
-    readAt: row.read_at ? normalizeDateLike(row.read_at) : null,
-    createdAt: normalizeDateLike(row.created_at),
-    updatedAt: normalizeDateLike(row.updated_at)
-  });
-}
-function serializeNotificationRecordForRow(record) {
-  return {
-    id: record.id,
-    type: record.type ?? null,
-    notifiable_type: record.notifiableType,
-    notifiable_id: String(record.notifiableId),
-    data: JSON.stringify(record.data ?? null),
-    read_at: record.readAt ? record.readAt.toISOString() : null,
-    created_at: record.createdAt.toISOString(),
-    updated_at: record.updatedAt.toISOString()
-  };
+  return value.startsWith(".") || !value.startsWith("/") ? resolve5(projectRoot, value) : value;
 }
 function getEntityAttributes(value) {
   if (value && typeof value === "object") {
@@ -942,20 +1361,20 @@ async function createCoreManagedSessionStores(projectRoot, loadedConfig, session
       const connectionName = config.connection === "default" && !(config.connection in loadedConfig.database.connections) ? loadedConfig.database.defaultConnection : config.connection;
       stores[name] = sessionModule.createDatabaseSessionStore({
         async read(sessionId) {
-          const row = await DB.table(config.table, connectionName).where("id", sessionId).whereNull("invalidated_at").first();
+          const row = await DB2.table(config.table, connectionName).where("id", sessionId).whereNull("invalidated_at").first();
           return row ? normalizeSessionRecordFromRow(row) : null;
         },
         async write(record) {
           const normalized = serializeSessionRecordForRow(record);
-          const existing = await DB.table(config.table, connectionName).find(String(normalized.id));
+          const existing = await DB2.table(config.table, connectionName).find(String(normalized.id));
           if (existing) {
-            await DB.table(config.table, connectionName).where("id", normalized.id).update(normalized);
+            await DB2.table(config.table, connectionName).where("id", normalized.id).update(normalized);
             return;
           }
-          await DB.table(config.table, connectionName).insert(normalized);
+          await DB2.table(config.table, connectionName).insert(normalized);
         },
         async delete(sessionId) {
-          await DB.table(config.table, connectionName).where("id", sessionId).delete();
+          await DB2.table(config.table, connectionName).where("id", sessionId).delete();
         }
       });
       continue;
@@ -1000,59 +1419,6 @@ async function createCoreManagedSessionStores(projectRoot, loadedConfig, session
 async function createCoreSessionStores(projectRoot, loadedConfig, sessionModule) {
   return (await createCoreManagedSessionStores(projectRoot, loadedConfig, sessionModule)).stores;
 }
-function createCoreNotificationStore(loadedConfig) {
-  const tableName = loadedConfig.notifications.table;
-  const connectionName = loadedConfig.database.defaultConnection;
-  const store = {
-    async create(record) {
-      await DB.table(tableName, connectionName).insert(serializeNotificationRecordForRow(record));
-    },
-    async list(notifiable) {
-      const rows = await DB.table(tableName, connectionName).where("notifiable_type", notifiable.type).where("notifiable_id", String(notifiable.id)).orderBy("created_at", "desc").get();
-      return Object.freeze(rows.map((row) => normalizeNotificationRecordFromRow(row)));
-    },
-    async unread(notifiable) {
-      const rows = await DB.table(tableName, connectionName).where("notifiable_type", notifiable.type).where("notifiable_id", String(notifiable.id)).whereNull("read_at").orderBy("created_at", "desc").get();
-      return Object.freeze(rows.map((row) => normalizeNotificationRecordFromRow(row)));
-    },
-    async markAsRead(ids) {
-      if (ids.length === 0) {
-        return 0;
-      }
-      const result = await DB.table(tableName, connectionName).whereIn("id", ids).update({
-        read_at: (/* @__PURE__ */ new Date()).toISOString(),
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return result.affectedRows ?? 0;
-    },
-    async markAsUnread(ids) {
-      if (ids.length === 0) {
-        return 0;
-      }
-      const result = await DB.table(tableName, connectionName).whereIn("id", ids).update({
-        read_at: null,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return result.affectedRows ?? 0;
-    },
-    async delete(ids) {
-      if (ids.length === 0) {
-        return 0;
-      }
-      const result = await DB.table(tableName, connectionName).whereIn("id", ids).delete();
-      return result.affectedRows ?? 0;
-    }
-  };
-  return Object.freeze(store);
-}
-var authEmailDateFormatter = new Intl.DateTimeFormat("en-US", {
-  dateStyle: "long",
-  timeStyle: "short",
-  timeZone: "UTC"
-});
-function formatAuthEmailExpiration(expiresAt) {
-  return `${authEmailDateFormatter.format(expiresAt)} UTC`;
-}
 var AUTH_EMAIL_VERIFICATION_NOTIFICATION_PATHS = [
   "server/notifications/auth/email-verification.ts",
   "server/notifications/auth/email-verification.mts",
@@ -1073,7 +1439,7 @@ function resolveExistingProjectFile(projectRoot, candidates) {
   if (!projectRoot) {
     return void 0;
   }
-  return candidates.find((candidate) => existsSync(resolve3(projectRoot, candidate)));
+  return candidates.find((candidate) => existsSync2(resolve5(projectRoot, candidate)));
 }
 function resolveAuthNotification(module, exportName, filePath) {
   const notification = module[exportName] ?? module.notification ?? module.default;
@@ -1232,219 +1598,92 @@ function createCoreNotificationBroadcaster(broadcastModule) {
         event,
         channels,
         payload: Object.freeze({
-          ...typeof context.notificationType === "string" && context.notificationType.trim() ? { type: context.notificationType.trim() } : {},
-          data: message.data ?? null
-        })
-      });
-    }
-  });
-}
-function createCoreBroadcastPublisher(loadedConfig) {
-  const connectionHosts = /* @__PURE__ */ new Set(["holo", "pusher"]);
-  const publish = async (input, context) => {
-    const connection = loadedConfig.connections[input.connection];
-    if (!connection) {
-      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" is not configured.`);
-    }
-    if (!("appId" in connection) || !("key" in connection) || !("secret" in connection)) {
-      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" cannot be published automatically.`);
-    }
-    if (!connectionHosts.has(connection.driver)) {
-      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" cannot be published automatically.`);
-    }
-    const options = connection.options;
-    const protocol = options.scheme === "http" ? "http:" : "https:";
-    const url = new URL(`/apps/${encodeURIComponent(connection.appId)}/events`, `${protocol}//${options.host}`);
-    if (typeof options.port === "number") {
-      url.port = String(options.port);
-    }
-    const body = JSON.stringify({
-      name: input.event,
-      channels: input.channels,
-      data: JSON.stringify(input.payload),
-      /* v8 ignore next -- tests do not pass socketId through the publish binding */
-      ...typeof input.socketId === "undefined" ? {} : { socket_id: input.socketId }
-    });
-    const bodyMd5 = createHash("md5").update(body).digest("hex");
-    url.searchParams.set("auth_key", connection.key);
-    url.searchParams.set("auth_timestamp", String(Math.floor(Date.now() / 1e3)));
-    url.searchParams.set("auth_version", "1.0");
-    url.searchParams.set("body_md5", bodyMd5);
-    url.searchParams.set(
-      "auth_signature",
-      createHmac("sha256", connection.secret).update(
-        [
-          "POST",
-          url.pathname,
-          [...url.searchParams.entries()].filter(([key]) => key !== "auth_signature").sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
-        ].join("\n")
-      ).digest("hex")
-    );
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), BROADCAST_PUBLISH_TIMEOUT_MS);
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json"
-        },
-        body,
-        signal: controller.signal
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`[@holo-js/core] Broadcast publish request timed out after ${BROADCAST_PUBLISH_TIMEOUT_MS}ms.`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-    if (!response.ok) {
-      throw new Error(`[@holo-js/core] Broadcast publish request failed with status ${response.status}.`);
-    }
-    const result = await response.json();
-    return {
-      connection: input.connection,
-      driver: connection.driver,
-      queued: context.queued,
-      publishedChannels: Array.isArray(result.deliveredChannels) ? Object.freeze(result.deliveredChannels.map((value) => String(value))) : Object.freeze([...input.channels])
-    };
-  };
-  Object.defineProperty(publish, CORE_BROADCAST_PUBLISHER_MARKER, {
-    value: true
-  });
-  return publish;
-}
-function isCoreBroadcastPublisher(value) {
-  return typeof value === "function" && CORE_BROADCAST_PUBLISHER_MARKER in value;
-}
-function createNotificationMailText(message) {
-  const parts = [
-    typeof message.greeting === "string" ? message.greeting.trim() : void 0,
-    ...(message.lines ?? []).map((line) => line.trim()).filter(Boolean),
-    message.action ? `${message.action.label}: ${message.action.url}` : void 0
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return parts.length > 0 ? parts.join("\n\n") : void 0;
-}
-function createNotificationMailHtml(message) {
-  const greeting = typeof message.greeting === "string" ? message.greeting.trim() : void 0;
-  const lines = (message.lines ?? []).map((line) => line.trim()).filter(Boolean);
-  const sections = [
-    greeting ? `<p style="margin:0 0 16px;">${escapeAuthEmailHtml(greeting)}</p>` : "",
-    ...lines.map((line) => `<p style="margin:0 0 16px;">${escapeAuthEmailHtml(line)}</p>`),
-    message.action ? `<p style="margin:24px 0;"><a href="${escapeAuthEmailHtml(message.action.url)}" style="display:inline-block;padding:12px 18px;background:#111827;color:#ffffff;text-decoration:none;border-radius:8px;font-weight:600;">${escapeAuthEmailHtml(message.action.label)}</a></p>` : "",
-    message.action ? `<p style="margin:0;color:#475569;font-size:14px;">If the button does not work, open this link: <a href="${escapeAuthEmailHtml(message.action.url)}">${escapeAuthEmailHtml(message.action.url)}</a></p>` : ""
-  ].join("");
-  return [
-    "<!doctype html>",
-    '<html><head><meta charset="utf-8">',
-    `<title>${escapeAuthEmailHtml(message.subject)}</title>`,
-    '</head><body style="margin:0;padding:24px;font-family:Arial,sans-serif;color:#0f172a;background:#f8fafc;">',
-    '<div style="max-width:640px;margin:0 auto;background:#ffffff;border:1px solid #e2e8f0;border-radius:12px;padding:32px;">',
-    `<h1 style="margin:0 0 24px;font-size:24px;line-height:1.3;">${escapeAuthEmailHtml(message.subject)}</h1>`,
-    sections,
-    "</div></body></html>"
-  ].join("");
-}
-function joinAppUrl(baseUrl, path) {
-  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  return `${normalizedBaseUrl}${normalizedPath}`;
-}
-function createAuthActionUrl(appUrl, path, token) {
-  const url = new URL(joinAppUrl(appUrl, path));
-  url.searchParams.set("token", token);
-  return url.toString();
-}
-function escapeAuthEmailHtml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
-}
-function createAuthEmailHtml(message) {
-  return createNotificationMailHtml(message);
-}
-function createCoreNotificationMailSender(mailModule) {
-  return Object.freeze({
-    async send(message, context) {
-      const route = context.route;
-      if (!route) {
-        throw new Error("[@holo-js/core] Email notifications require a resolved email route before bridging into mail.");
-      }
-      const fallbackText = createNotificationMailText(message);
-      const fallbackHtml = createNotificationMailHtml(message);
-      await mailModule.sendMail({
-        to: route,
-        subject: message.subject,
-        html: typeof message.html === "string" ? message.html : fallbackHtml,
-        ...typeof (message.text ?? fallbackText) === "string" ? { text: message.text ?? fallbackText } : {},
-        ...message.metadata ? { metadata: message.metadata } : {}
-      });
-    }
-  });
-}
-function createAuthMailDeliveryHook(mailModule, appUrl) {
-  return Object.freeze({
-    async sendEmailVerification(input) {
-      const recipientName = typeof input.user?.name === "string" ? input.user.name?.trim() : void 0;
-      const lines = [
-        "Confirm your account to finish signing in.",
-        `This verification link expires at ${formatAuthEmailExpiration(input.token.expiresAt)}.`
-      ];
-      const action = {
-        label: "Verify email address",
-        url: createAuthActionUrl(appUrl, input.route, input.token.plainTextToken)
-      };
-      await mailModule.sendMail({
-        to: {
-          email: input.email,
-          ...recipientName ? { name: recipientName } : {}
-        },
-        subject: "Verify your email address",
-        html: createAuthEmailHtml({
-          subject: "Verify your email address",
-          ...recipientName ? { greeting: `Hello ${recipientName},` } : {},
-          lines,
-          action
-        }),
-        text: createNotificationMailText({
-          ...recipientName ? { greeting: `Hello ${recipientName},` } : {},
-          lines,
-          action
-        }),
-        metadata: {
-          provider: input.provider,
-          tokenId: input.token.id
-        }
+          ...typeof context.notificationType === "string" && context.notificationType.trim() ? { type: context.notificationType.trim() } : {},
+          data: message.data ?? null
+        })
       });
-    },
-    async sendPasswordReset(input) {
-      const lines = [
-        "Click the link below to choose a new password.",
-        `This reset link expires at ${formatAuthEmailExpiration(input.token.expiresAt)}.`
-      ];
-      const action = {
-        label: "Reset password",
-        url: createAuthActionUrl(appUrl, input.route, input.token.plainTextToken)
-      };
-      await mailModule.sendMail({
-        to: input.email,
-        subject: "Reset your password",
-        html: createAuthEmailHtml({
-          subject: "Reset your password",
-          lines,
-          action
-        }),
-        text: createNotificationMailText({
-          lines,
-          action
-        }),
-        metadata: {
-          provider: input.provider,
-          tokenId: input.token.id
-        }
+    }
+  });
+}
+function createCoreBroadcastPublisher(loadedConfig) {
+  const connectionHosts = /* @__PURE__ */ new Set(["holo", "pusher"]);
+  const publish = async (input, context) => {
+    const connection = loadedConfig.connections[input.connection];
+    if (!connection) {
+      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" is not configured.`);
+    }
+    if (!("appId" in connection) || !("key" in connection) || !("secret" in connection)) {
+      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" cannot be published automatically.`);
+    }
+    if (!connectionHosts.has(connection.driver)) {
+      throw new Error(`[@holo-js/core] Broadcast connection "${input.connection}" cannot be published automatically.`);
+    }
+    const options = connection.options;
+    const protocol = options.scheme === "http" ? "http:" : "https:";
+    const url = new URL(`/apps/${encodeURIComponent(connection.appId)}/events`, `${protocol}//${options.host}`);
+    if (typeof options.port === "number") {
+      url.port = String(options.port);
+    }
+    const body = JSON.stringify({
+      name: input.event,
+      channels: input.channels,
+      data: JSON.stringify(input.payload),
+      /* v8 ignore next -- tests do not pass socketId through the publish binding */
+      ...typeof input.socketId === "undefined" ? {} : { socket_id: input.socketId }
+    });
+    const bodyMd5 = createHash("md5").update(body).digest("hex");
+    url.searchParams.set("auth_key", connection.key);
+    url.searchParams.set("auth_timestamp", String(Math.floor(Date.now() / 1e3)));
+    url.searchParams.set("auth_version", "1.0");
+    url.searchParams.set("body_md5", bodyMd5);
+    url.searchParams.set(
+      "auth_signature",
+      createHmac("sha256", connection.secret).update(
+        [
+          "POST",
+          url.pathname,
+          [...url.searchParams.entries()].filter(([key]) => key !== "auth_signature").sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
+        ].join("\n")
+      ).digest("hex")
+    );
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), BROADCAST_PUBLISH_TIMEOUT_MS);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body,
+        signal: controller.signal
       });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`[@holo-js/core] Broadcast publish request timed out after ${BROADCAST_PUBLISH_TIMEOUT_MS}ms.`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (!response.ok) {
+      throw new Error(`[@holo-js/core] Broadcast publish request failed with status ${response.status}.`);
     }
+    const result = await response.json();
+    return {
+      connection: input.connection,
+      driver: connection.driver,
+      queued: context.queued,
+      publishedChannels: Array.isArray(result.deliveredChannels) ? Object.freeze(result.deliveredChannels.map((value) => String(value))) : Object.freeze([...input.channels])
+    };
+  };
+  Object.defineProperty(publish, CORE_BROADCAST_PUBLISHER_MARKER, {
+    value: true
   });
+  return publish;
+}
+function isCoreBroadcastPublisher(value) {
+  return typeof value === "function" && CORE_BROADCAST_PUBLISHER_MARKER in value;
 }
 async function loadConfiguredSocialProviders(projectRootOrLoadedConfig, maybeLoadedConfig) {
   const projectRoot = typeof projectRootOrLoadedConfig === "string" ? projectRootOrLoadedConfig : (
@@ -1471,97 +1710,6 @@ async function loadConfiguredSocialProviders(projectRootOrLoadedConfig, maybeLoa
   }
   return Object.freeze(providers);
 }
-function normalizeDateValue(value) {
-  return value instanceof Date ? value : new Date(String(value));
-}
-function normalizeJsonValue(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-function normalizeStoredUserId(value) {
-  return typeof value === "number" ? value : String(value);
-}
-function normalizeAccessTokenRecord(row) {
-  const abilities = normalizeJsonValue(row.abilities);
-  return Object.freeze({
-    id: String(row.id),
-    provider: String(row.provider),
-    userId: normalizeStoredUserId(row.user_id),
-    name: String(row.name),
-    abilities: Array.isArray(abilities) ? Object.freeze([...abilities]) : Object.freeze([]),
-    tokenHash: String(row.token_hash),
-    createdAt: normalizeDateValue(row.created_at),
-    lastUsedAt: row.last_used_at ? normalizeDateValue(row.last_used_at) : void 0,
-    expiresAt: row.expires_at ? normalizeDateValue(row.expires_at) : null
-  });
-}
-function serializeAccessTokenRecord(record) {
-  return {
-    id: record.id,
-    provider: record.provider,
-    user_id: String(record.userId),
-    name: record.name,
-    abilities: JSON.stringify(record.abilities),
-    token_hash: record.tokenHash,
-    created_at: record.createdAt.toISOString(),
-    last_used_at: record.lastUsedAt?.toISOString() ?? null,
-    expires_at: record.expiresAt?.toISOString() ?? null,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeEmailVerificationTokenRecord(row) {
-  return Object.freeze({
-    id: String(row.id),
-    provider: String(row.provider),
-    userId: normalizeStoredUserId(row.user_id),
-    email: String(row.email),
-    tokenHash: String(row.token_hash),
-    createdAt: normalizeDateValue(row.created_at),
-    expiresAt: normalizeDateValue(row.expires_at)
-  });
-}
-function serializeEmailVerificationTokenRecord(record) {
-  return {
-    id: record.id,
-    provider: record.provider,
-    user_id: String(record.userId),
-    email: record.email,
-    token_hash: record.tokenHash,
-    created_at: record.createdAt.toISOString(),
-    expires_at: record.expiresAt.toISOString(),
-    used_at: null,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizePasswordResetTokenRecord(row) {
-  return Object.freeze({
-    id: String(row.id),
-    provider: typeof row.provider === "string" ? row.provider : "users",
-    email: String(row.email),
-    table: typeof row.__holo_table === "string" ? row.__holo_table : void 0,
-    tokenHash: String(row.token_hash),
-    createdAt: normalizeDateValue(row.created_at),
-    expiresAt: normalizeDateValue(row.expires_at)
-  });
-}
-function serializePasswordResetTokenRecord(record) {
-  return {
-    id: record.id,
-    provider: record.provider,
-    email: record.email,
-    token_hash: record.tokenHash,
-    created_at: record.createdAt.toISOString(),
-    expires_at: record.expiresAt.toISOString(),
-    used_at: null,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
 async function createCoreSocialBindings(projectRootOrLoadedConfig, loadedConfigOrSessionModule, maybeSessionModule) {
   const projectRoot = typeof projectRootOrLoadedConfig === "string" ? projectRootOrLoadedConfig : (
     /* turbopackIgnore: true */
@@ -1609,7 +1757,7 @@ async function createCoreSocialBindings(projectRootOrLoadedConfig, loadedConfigO
   });
   const identityStore = Object.freeze({
     async findByProviderUserId(provider, providerUserId) {
-      const row = await DB.table("auth_identities").where("provider", provider).where("provider_user_id", providerUserId).first();
+      const row = await DB2.table("auth_identities").where("provider", provider).where("provider_user_id", providerUserId).first();
       if (!row) {
         return null;
       }
@@ -1631,7 +1779,7 @@ async function createCoreSocialBindings(projectRootOrLoadedConfig, loadedConfigO
     },
     async save(record) {
       const value = record;
-      const existing = await DB.table("auth_identities").where("provider", value.provider).where("provider_user_id", value.providerUserId).first();
+      const existing = await DB2.table("auth_identities").where("provider", value.provider).where("provider_user_id", value.providerUserId).first();
       const payload = {
         user_id: String(value.userId),
         provider: value.provider,
@@ -1646,10 +1794,10 @@ async function createCoreSocialBindings(projectRootOrLoadedConfig, loadedConfigO
         updated_at: value.updatedAt.toISOString()
       };
       if (existing && typeof existing.id !== "undefined") {
-        await DB.table("auth_identities").where("id", existing.id).update(payload);
+        await DB2.table("auth_identities").where("id", existing.id).update(payload);
         return;
       }
-      await DB.table("auth_identities").insert(payload);
+      await DB2.table("auth_identities").insert(payload);
     }
   });
   return Object.freeze({
@@ -1683,7 +1831,7 @@ function createCoreHostedIdentityStore(namespace) {
   };
   const findStoredIdentity = async (provider, providerUserId, authProvider = "users") => {
     const providerValue = toHostedIdentityProviderValue(namespace, provider);
-    const row = await DB.table("auth_identities").where("provider", providerValue).where("provider_user_id", providerUserId).first();
+    const row = await DB2.table("auth_identities").where("provider", providerValue).where("provider_user_id", providerUserId).first();
     return row ? normalizeRow(row, { provider, providerUserId, authProvider }) : null;
   };
   const toPayload = (record) => {
@@ -1707,7 +1855,7 @@ function createCoreHostedIdentityStore(namespace) {
     },
     async findByUserId(provider, authProvider, userId) {
       const providerValue = toHostedIdentityProviderValue(namespace, provider);
-      const row = await DB.table("auth_identities").where("provider", providerValue).where("auth_provider", authProvider).where("user_id", String(userId)).first();
+      const row = await DB2.table("auth_identities").where("provider", providerValue).where("auth_provider", authProvider).where("user_id", String(userId)).first();
       if (!row) {
         return null;
       }
@@ -1719,7 +1867,7 @@ function createCoreHostedIdentityStore(namespace) {
     },
     async claim(record) {
       const value = record;
-      await DB.table("auth_identities").insertOrIgnore(toPayload(value));
+      await DB2.table("auth_identities").insertOrIgnore(toPayload(value));
       const claimed = await findStoredIdentity(value.provider, value.providerUserId, value.authProvider);
       if (!claimed) {
         throw new Error("[@holo-js/core] Claimed hosted identity could not be read back from auth_identities.");
@@ -1729,13 +1877,13 @@ function createCoreHostedIdentityStore(namespace) {
     async save(record) {
       const value = record;
       const providerValue = toHostedIdentityProviderValue(namespace, value.provider);
-      const existing = await DB.table("auth_identities").where("provider", providerValue).where("provider_user_id", value.providerUserId).first();
+      const existing = await DB2.table("auth_identities").where("provider", providerValue).where("provider_user_id", value.providerUserId).first();
       const payload = toPayload(value);
       if (existing && typeof existing.id !== "undefined") {
-        await DB.table("auth_identities").where("id", existing.id).update(payload);
+        await DB2.table("auth_identities").where("id", existing.id).update(payload);
         return;
       }
-      await DB.table("auth_identities").insert(payload);
+      await DB2.table("auth_identities").insert(payload);
     }
   });
 }
@@ -1743,55 +1891,55 @@ function createCoreAuthStores(loadedConfig) {
   return Object.freeze({
     tokens: Object.freeze({
       async create(record) {
-        await DB.table("personal_access_tokens").insert(serializeAccessTokenRecord(record));
+        await DB2.table("personal_access_tokens").insert(serializeAccessTokenRecord(record));
       },
       async findById(id) {
-        const row = await DB.table("personal_access_tokens").find(id);
+        const row = await DB2.table("personal_access_tokens").find(id);
         return row ? normalizeAccessTokenRecord(row) : null;
       },
       async listByUserId(provider, userId) {
-        const rows = await DB.table("personal_access_tokens").where("provider", provider).where("user_id", String(userId)).get();
+        const rows = await DB2.table("personal_access_tokens").where("provider", provider).where("user_id", String(userId)).get();
         return Object.freeze(rows.map((row) => normalizeAccessTokenRecord(row)));
       },
       async update(record) {
         const payload = serializeAccessTokenRecord(record);
-        await DB.table("personal_access_tokens").where("id", String(payload.id)).update(payload);
+        await DB2.table("personal_access_tokens").where("id", String(payload.id)).update(payload);
       },
       async delete(id) {
-        await DB.table("personal_access_tokens").where("id", id).delete();
+        await DB2.table("personal_access_tokens").where("id", id).delete();
       },
       async deleteByUserId(provider, userId) {
-        const result = await DB.table("personal_access_tokens").where("provider", provider).where("user_id", String(userId)).delete();
+        const result = await DB2.table("personal_access_tokens").where("provider", provider).where("user_id", String(userId)).delete();
         return result.affectedRows ?? 0;
       }
     }),
     emailVerificationTokens: Object.freeze({
       async create(record) {
-        await DB.table("email_verification_tokens").insert(serializeEmailVerificationTokenRecord(record));
+        await DB2.table("email_verification_tokens").insert(serializeEmailVerificationTokenRecord(record));
       },
       async findById(id) {
-        const row = await DB.table("email_verification_tokens").where("id", id).whereNull("used_at").first();
+        const row = await DB2.table("email_verification_tokens").where("id", id).whereNull("used_at").first();
         return row ? normalizeEmailVerificationTokenRecord(row) : null;
       },
       async delete(id) {
-        await DB.table("email_verification_tokens").where("id", id).delete();
+        await DB2.table("email_verification_tokens").where("id", id).delete();
       },
       async deleteByUserId(provider, userId) {
-        const result = await DB.table("email_verification_tokens").where("provider", provider).where("user_id", String(userId)).delete();
+        const result = await DB2.table("email_verification_tokens").where("provider", provider).where("user_id", String(userId)).delete();
         return result.affectedRows ?? 0;
       }
     }),
     passwordResetTokens: Object.freeze({
       async create(record) {
         const value = record;
-        await DB.table(value.table ?? "password_reset_tokens").insert(serializePasswordResetTokenRecord(value));
+        await DB2.table(value.table ?? "password_reset_tokens").insert(serializePasswordResetTokenRecord(value));
       },
       async findById(id) {
         const tables = Array.from(new Set(
           Object.values(loadedConfig.auth.passwords).map((config) => config.table)
         ));
         for (const table of tables) {
-          const row = await DB.table(table).where("id", id).whereNull("used_at").first();
+          const row = await DB2.table(table).where("id", id).whereNull("used_at").first();
           if (row) {
             return normalizePasswordResetTokenRecord({
               ...row,
@@ -1803,7 +1951,7 @@ function createCoreAuthStores(loadedConfig) {
       },
       async findLatestByEmail(provider, email, options) {
         const table = options?.table ?? "password_reset_tokens";
-        const row = await DB.table(table).where("provider", provider).where("email", email).latest("created_at").first();
+        const row = await DB2.table(table).where("provider", provider).where("email", email).latest("created_at").first();
         if (!row) {
           return null;
         }
@@ -1814,20 +1962,20 @@ function createCoreAuthStores(loadedConfig) {
       },
       async delete(id, options) {
         const table = options?.table ?? "password_reset_tokens";
-        await DB.table(table).where("id", id).delete();
+        await DB2.table(table).where("id", id).delete();
       },
       async deleteByEmail(provider, email, options) {
         const table = options?.table ?? "password_reset_tokens";
-        const result = await DB.table(table).where("provider", provider).where("email", email).delete();
+        const result = await DB2.table(table).where("provider", provider).where("email", email).delete();
         return result.affectedRows ?? 0;
       }
     })
   });
 }
 async function resolveAuthProviderRuntime(projectRoot, loadedConfig, modelName) {
-  const modelsRoot = resolve3(projectRoot, loadedConfig.app.paths.models);
+  const modelsRoot = resolve5(projectRoot, loadedConfig.app.paths.models);
   for (const extension of [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"]) {
-    const candidate = resolve3(modelsRoot, `${modelName}${extension}`);
+    const candidate = resolve5(modelsRoot, `${modelName}${extension}`);
     try {
       const moduleValue = await importRuntimeModule(projectRoot, candidate);
       if ("default" in moduleValue) {
@@ -2053,7 +2201,7 @@ async function registerProjectQueueJobs(projectRoot, registry, queueModule) {
       if (existing && !existing.sourcePath) {
         continue;
       }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
+      const moduleValue = await importRuntimeModule(projectRoot, resolve5(projectRoot, entry.sourcePath));
       const job = resolveQueueJobExport(queueModule, moduleValue);
       if (!job) {
         throw new Error(`Discovered job "${entry.sourcePath}" does not export a Holo job.`);
@@ -2118,7 +2266,7 @@ async function registerProjectAuthorizationDefinitions(projectRoot, registry, au
         previousPolicies.set(entry.name, existing);
         authorizationModule.authorizationInternals.unregisterPolicyDefinition(entry.name);
       }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
+      const moduleValue = await importRuntimeModule(projectRoot, resolve5(projectRoot, entry.sourcePath));
       const policy = resolveAuthorizationDefinitionExport(
         moduleValue,
         entry.exportName,
@@ -2146,7 +2294,7 @@ async function registerProjectAuthorizationDefinitions(projectRoot, registry, au
         previousAbilities.set(entry.name, existing);
         authorizationModule.authorizationInternals.unregisterAbilityDefinition(entry.name);
       }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
+      const moduleValue = await importRuntimeModule(projectRoot, resolve5(projectRoot, entry.sourcePath));
       const ability = resolveAuthorizationDefinitionExport(
         moduleValue,
         entry.exportName,
@@ -2214,7 +2362,7 @@ async function registerProjectEventsAndListeners(projectRoot, registry, eventsMo
       if (existing && !existing.sourcePath) {
         continue;
       }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
+      const moduleValue = await importRuntimeModule(projectRoot, resolve5(projectRoot, entry.sourcePath));
       const event = resolveEventExport(moduleValue);
       if (!event || !eventsModule.isEventDefinition(event)) {
         throw new Error(`Discovered event "${entry.sourcePath}" does not export a Holo event.`);
@@ -2231,7 +2379,7 @@ async function registerProjectEventsAndListeners(projectRoot, registry, eventsMo
       if (existing && !existing.sourcePath) {
         continue;
       }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
+      const moduleValue = await importRuntimeModule(projectRoot, resolve5(projectRoot, entry.sourcePath));
       const listener = resolveListenerExport(eventsModule, moduleValue);
       if (!listener) {
         throw new Error(`Discovered listener "${entry.sourcePath}" does not export a Holo listener.`);
@@ -2277,13 +2425,27 @@ function unregisterProjectEventsAndListeners(eventsModule, eventNames, listenerI
   }
 }
 async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, options = {}) {
+  const pluginDefinitions = await loadConfiguredHoloPluginDefinitions(projectRoot, resolveLoadedPluginNames(loadedConfig));
   const cacheConfigured = hasLoadedConfigFile(loadedConfig, "cache");
   const cacheModule = await loadCacheModule(cacheConfigured, projectRoot);
-  if (cacheModule) {
+  const cacheConfig = loadedConfig.cache;
+  if (cacheModule && cacheConfig) {
+    await loadConfiguredCacheDrivers(projectRoot, cacheConfig);
+    const configuredPluginDrivers = Object.entries(cacheConfig.drivers).flatMap(([name, driver]) => {
+      if (driver.driver === "memory" || driver.driver === "file" || driver.driver === "redis" || driver.driver === "database") return [];
+      return [{ ...driver, name, driver: driver.driver }];
+    });
+    const loadedPluginDrivers = await cacheModule.loadConfiguredCachePluginDriverContracts(
+      projectRoot,
+      resolveLoadedPluginNames(loadedConfig),
+      configuredPluginDrivers
+    );
+    const cachePluginDrivers = new Map(loadedPluginDrivers.map((driver) => [driver.name, driver]));
     cacheModule.configureCacheRuntime({
-      config: loadedConfig.cache,
+      config: cacheConfig,
       databaseConfig: loadedConfig.database,
-      redisConfig: loadedConfig.redis
+      redisConfig: loadedConfig.redis,
+      ...cachePluginDrivers.size > 0 ? { drivers: cachePluginDrivers } : {}
     });
   }
   const queueConfigured = hasLoadedConfigFile(loadedConfig, "queue");
@@ -2291,14 +2453,30 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
   if (queueModule) {
     const queueUsesExplicitDatabaseFeatures = queueConfigured && (queueConfigUsesDatabaseDriver(loadedConfig) || queueConfigUsesDatabaseBackedFailedStore(loadedConfig));
     const queueUsesImplicitDefaultFailedStore = !queueConfigured && queueConfigUsesDatabaseBackedFailedStore(loadedConfig);
-    const queueDbModule = queueUsesExplicitDatabaseFeatures || queueUsesImplicitDefaultFailedStore ? await loadQueueDbModule() : void 0;
+    const queueDbModule = queueUsesExplicitDatabaseFeatures || queueUsesImplicitDefaultFailedStore ? await loadQueueDbModule(projectRoot) : void 0;
+    const queueUsesRedis = queueConfigUsesRedisDriver(loadedConfig);
+    const queueRedisModule = queueUsesRedis ? await loadQueueRedisModule(projectRoot) : void 0;
     if (queueUsesExplicitDatabaseFeatures && !queueDbModule) {
       throw new Error("[@holo-js/core] Database-backed queue features require @holo-js/queue-db to be installed.");
     }
+    if (queueUsesRedis && !queueRedisModule) {
+      throw new Error("[@holo-js/core] Redis-backed queue connections require @holo-js/queue-redis to be installed.");
+    }
+    const queuePluginDriverFactories = await queueModule.loadQueuePluginDriverFactories(
+      projectRoot,
+      resolveLoadedPluginNames(loadedConfig)
+    );
+    const queueDbRuntimeOptions = queueDbModule?.createQueueDbRuntimeOptions() ?? {};
+    const queueDriverFactories = mergeQueueRuntimeDriverFactories(
+      queuePluginDriverFactories,
+      queueDbRuntimeOptions.driverFactories,
+      queueRedisModule ? [queueRedisModule.redisQueueDriverFactory] : void 0
+    );
     queueModule.configureQueueRuntime({
       config: loadedConfig.queue,
       redisConfig: loadedConfig.redis,
-      ...queueDbModule?.createQueueDbRuntimeOptions() ?? {}
+      ...queueDbRuntimeOptions,
+      ...queueDriverFactories.length > 0 ? { driverFactories: queueDriverFactories } : {}
     });
   }
   const storageConfigured = hasLoadedConfigFile(loadedConfig, "storage");
@@ -2306,7 +2484,7 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
   if (!storageInstalled && storageConfigured) {
     throw new Error("[@holo-js/core] Storage support requires @holo-js/storage to be installed.");
   }
-  if (storageInstalled) {
+  if (storageInstalled && loadedConfig.storage) {
     await configurePlainNodeStorageRuntime(projectRoot, loadedConfig);
   }
   const mailConfigured = hasLoadedConfigFile(loadedConfig, "mail");
@@ -2316,7 +2494,9 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
     mailModule.configureMailRuntime({
       ...existingMailBindings,
       config: loadedConfig.mail,
-      ...options.renderView ?? getRuntimeState().renderView ? { renderView: options.renderView ?? getRuntimeState().renderView } : {}
+      projectRoot,
+      plugins: loadedConfig.app.plugins,
+      ...options.renderView ?? getHoloRenderingRuntime().renderView ? { renderView: options.renderView ?? getHoloRenderingRuntime().renderView } : {}
     });
   }
   const broadcastConfigured = hasLoadedConfigFile(loadedConfig, "broadcast");
@@ -2326,6 +2506,8 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
     broadcastModule.configureBroadcastRuntime({
       ...existingBroadcastBindings,
       config: loadedConfig.broadcast,
+      projectRoot,
+      plugins: loadedConfig.app.plugins,
       ...!existingBroadcastBindings.publish || isCoreBroadcastPublisher(existingBroadcastBindings.publish) ? {
         publish: createCoreBroadcastPublisher(loadedConfig.broadcast)
       } : {}
@@ -2338,6 +2520,16 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
     notificationsModule.configureNotificationsRuntime({
       ...existingNotificationsBindings,
       config: loadedConfig.notifications,
+      deferAfterCommit(callback) {
+        const connection = connectionAsyncContext.getActive()?.connection;
+        if (!connection || connection.getScope().kind === "root") {
+          return false;
+        }
+        connection.afterCommit(callback);
+        return true;
+      },
+      projectRoot,
+      plugins: loadedConfig.app.plugins,
       store: existingNotificationsBindings.store ?? createCoreNotificationStore(loadedConfig),
       ...!existingNotificationsBindings.mailer && mailModule ? { mailer: createCoreNotificationMailSender(mailModule) } : {},
       ...!existingNotificationsBindings.broadcaster && broadcastModule ? { broadcaster: createCoreNotificationBroadcaster(broadcastModule) } : {}
@@ -2509,6 +2701,9 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
   } else if (authorizationModule) {
     authorizationModule.authorizationInternals.resetAuthorizationAuthIntegration();
   }
+  for (const bootModule of await loadConfiguredHoloPluginBootModules(projectRoot, pluginDefinitions)) {
+    await bootConfiguredHoloPluginModule(projectRoot, loadedConfig, bootModule);
+  }
   return Object.freeze({
     /* v8 ignore next -- only toggles shape when queue support is absent */
     ...queueModule ? { queueModule } : {},
@@ -2518,6 +2713,7 @@ async function reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, opti
   });
 }
 async function resetOptionalHoloSubsystems() {
+  resetBootedHoloPluginModules();
   const projectRoot = getRuntimeState().current?.projectRoot ?? getRuntimeState().pendingProjectRoot;
   await resetOptionalStorageRuntime();
   const cacheModule = await loadCacheModule(false, projectRoot);
@@ -2527,7 +2723,10 @@ async function resetOptionalHoloSubsystems() {
     resetCacheRuntimeGlobalsFallback();
   }
   const queueModule = await loadQueueModule();
-  await queueModule?.shutdownQueueRuntime();
+  if (queueModule) {
+    await queueModule.shutdownQueueRuntime();
+    queueModule.resetQueueRuntime?.();
+  }
   const mailModule = await loadMailModule();
   mailModule?.resetMailRuntime();
   const notificationsModule = await loadNotificationsModule();
@@ -2567,15 +2766,32 @@ async function resetOptionalHoloSubsystems() {
   securityModule?.resetSecurityRuntime();
 }
 async function createHolo(projectRoot, options = {}) {
+  await loadInstalledFeatureConfigContributions(projectRoot);
   const loadedConfig = await loadConfigDirectory(projectRoot, {
     envName: options.envName,
     preferCache: options.preferCache,
     processEnv: options.processEnv
   });
+  const fallbackQueueConfig = Object.freeze({
+    default: "sync",
+    failed: Object.freeze({
+      driver: "database",
+      connection: "default",
+      table: "failed_jobs"
+    }),
+    connections: Object.freeze({
+      sync: Object.freeze({
+        driver: "sync",
+        queue: "default"
+      })
+    })
+  });
+  const queueConfig = loadedConfig.queue ?? fallbackQueueConfig;
   const runtimeConfig = {
     db: loadedConfig.database,
-    queue: loadedConfig.queue
+    queue: queueConfig
   };
+  const databaseDriverFactories = await loadConfiguredDatabaseDrivers(projectRoot, loadedConfig);
   const manager = resolveRuntimeConnectionManagerOptions(runtimeConfig);
   const registry = await loadGeneratedProjectRegistry(projectRoot);
   const accessors = createConfigAccessors(loadedConfig.all);
@@ -2591,11 +2807,105 @@ async function createHolo(projectRoot, options = {}) {
   let activeAuthRuntime;
   let activeAuthContext;
   let previousOptionalSubsystemBindings;
-  const previousRenderView = options.renderView ? getRuntimeState().renderView : void 0;
+  const previousRenderView = options.renderView ? getHoloRenderingRuntime().renderView : void 0;
   const fallbackQueueRuntime = Object.freeze({
-    config: loadedConfig.queue,
+    config: queueConfig,
     drivers: /* @__PURE__ */ new Map()
   });
+  const unregisterRuntimeContributions = () => {
+    unregisterProjectEventsAndListeners(activeEventsModule, runtimeOwnedEventNames, runtimeOwnedListenerIds);
+    runtimeOwnedEventNames.splice(0);
+    runtimeOwnedListenerIds.splice(0);
+    unregisterProjectAuthorizationDefinitions(activeAuthorizationModule, runtimeOwnedAuthorizationPolicyNames, runtimeOwnedAuthorizationAbilityNames);
+    runtimeOwnedAuthorizationPolicyNames.splice(0);
+    runtimeOwnedAuthorizationAbilityNames.splice(0);
+    unregisterProjectQueueJobs(activeQueueModule, runtimeOwnedQueueJobNames);
+    runtimeOwnedQueueJobNames.splice(0);
+    activeAuthorizationModule = void 0;
+    activeEventsModule = void 0;
+    activeQueueModule = void 0;
+    activeSessionRuntime = void 0;
+    activeAuthRuntime = void 0;
+    activeAuthContext = void 0;
+  };
+  const initializeRuntimeServices = async () => {
+    if (!shouldBootRuntimeServices(options.processEnv)) return;
+    const optionalSubsystems = await reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, {
+      renderView: options.renderView,
+      authRequest: options.authRequest,
+      authorizationError: options.authorizationError
+    });
+    activeQueueModule = optionalSubsystems.queueModule;
+    activeSessionRuntime = optionalSubsystems.session;
+    activeAuthRuntime = optionalSubsystems.auth;
+    activeAuthContext = optionalSubsystems.authContext;
+    const optionalEventsModule = activeQueueModule ? await loadEventsModule() : void 0;
+    if (activeQueueModule && optionalEventsModule) {
+      await optionalEventsModule.ensureEventsQueueJobRegisteredAsync?.();
+    }
+    if (registryHasEvents(registry)) {
+      const eventsModule = await loadEventsModule(true);
+      if (!eventsModule) throw new Error("[@holo-js/core] Events support requires @holo-js/events to be installed.");
+      activeEventsModule = eventsModule;
+      const eventRegistration = await registerProjectEventsAndListeners(projectRoot, registry, eventsModule, activeQueueModule);
+      runtimeOwnedEventNames.push(...eventRegistration.eventNames);
+      runtimeOwnedListenerIds.push(...eventRegistration.listenerIds);
+    }
+    activeAuthorizationModule = await loadAuthorizationModule();
+    const authorizationRegistration = await registerProjectAuthorizationDefinitions(projectRoot, registry, activeAuthorizationModule);
+    runtimeOwnedAuthorizationPolicyNames.push(...authorizationRegistration.policyNames);
+    runtimeOwnedAuthorizationAbilityNames.push(...authorizationRegistration.abilityNames);
+    if (options.registerProjectQueueJobs !== false && registryHasJobs(registry)) {
+      if (!activeQueueModule) throw new Error("[@holo-js/core] Project jobs require @holo-js/queue to be installed.");
+      runtimeOwnedQueueJobNames.push(...await registerProjectQueueJobs(projectRoot, registry, activeQueueModule));
+    }
+  };
+  const runtimeLifecycle = createRuntimeLifecycle([
+    {
+      name: "configuration",
+      async initialize() {
+        configureConfigRuntime(loadedConfig.all);
+        await preloadGeneratedSchemaModule(projectRoot, registry);
+        await preloadDiscoveredModelModules(projectRoot, registry);
+        previousOptionalSubsystemBindings = snapshotOptionalSubsystemRuntimeBindings();
+        if (options.renderView) configureHoloRenderingRuntime({ renderView: options.renderView });
+      },
+      dispose() {
+        if (options.renderView) restoreHoloRenderingRuntime(previousRenderView);
+        resetConfigRuntime();
+      }
+    },
+    {
+      name: "database",
+      dependsOn: ["configuration"],
+      async initialize() {
+        for (const factory of databaseDriverFactories) registerDatabaseDriverFactory(factory);
+        configureDB(manager);
+        if (shouldBootRuntimeServices(options.processEnv)) await manager.initializeAll();
+      },
+      async dispose() {
+        try {
+          await manager.disconnectAll();
+        } finally {
+          resetDB();
+          for (const factory of [...databaseDriverFactories].reverse()) unregisterDatabaseDriverFactory(factory);
+        }
+      }
+    },
+    {
+      name: "optional-subsystems",
+      dependsOn: ["database"],
+      initialize: initializeRuntimeServices,
+      async dispose() {
+        unregisterRuntimeContributions();
+        try {
+          await resetOptionalHoloSubsystems();
+        } finally {
+          if (previousOptionalSubsystemBindings) restoreOptionalSubsystemRuntimeBindings(previousOptionalSubsystemBindings);
+        }
+      }
+    }
+  ]);
   const runtime = {
     projectRoot,
     loadedConfig,
@@ -2617,150 +2927,31 @@ async function createHolo(projectRoot, options = {}) {
     setAuthRequestAccessors(authRequest) {
       activeAuthContext?.setRequestAccessors?.(authRequest);
     },
-    async runWithAuthRequestAccessors(authRequest, callback) {
+    runWithAuthRequestAccessors(authRequest, callback) {
       const runner = activeAuthContext?.runWithRequestAccessors;
-      return runner ? await runner(authRequest, callback) : await callback();
+      return runner ? runner(authRequest, callback) : callback();
     },
     async initialize() {
-      if (runtime.initialized) {
-        throw new Error("Holo runtime is already initialized.");
-      }
-      if (getRuntimeState().current) {
-        throw new Error("A Holo runtime is already initialized for this process.");
-      }
-      configureConfigRuntime(loadedConfig.all);
-      configureDB(manager);
-      await preloadGeneratedSchemaModule(projectRoot, registry);
-      await preloadDiscoveredModelModules(projectRoot, registry);
-      previousOptionalSubsystemBindings = snapshotOptionalSubsystemRuntimeBindings();
-      if (options.renderView) {
-        configureHoloRenderingRuntime({
-          renderView: options.renderView
-        });
-      }
-      try {
-        if (shouldBootRuntimeServices(options.processEnv)) {
-          await manager.initializeAll();
-          const optionalSubsystems = await reconfigureOptionalHoloSubsystems(projectRoot, loadedConfig, {
-            renderView: options.renderView,
-            authRequest: options.authRequest,
-            authorizationError: options.authorizationError
-          });
-          activeQueueModule = optionalSubsystems.queueModule;
-          activeSessionRuntime = optionalSubsystems.session;
-          activeAuthRuntime = optionalSubsystems.auth;
-          activeAuthContext = optionalSubsystems.authContext;
-          const optionalEventsModule = activeQueueModule ? await loadEventsModule() : void 0;
-          if (activeQueueModule && optionalEventsModule) {
-            await optionalEventsModule.ensureEventsQueueJobRegisteredAsync?.();
-          }
-          if (registryHasEvents(registry)) {
-            const eventsModule = await loadEventsModule(true);
-            if (!eventsModule) {
-              throw new Error("[@holo-js/core] Events support requires @holo-js/events to be installed.");
-            }
-            activeEventsModule = eventsModule;
-            const eventRegistration = await registerProjectEventsAndListeners(
-              projectRoot,
-              registry,
-              eventsModule,
-              activeQueueModule
-            );
-            runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length, ...eventRegistration.eventNames);
-            runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length, ...eventRegistration.listenerIds);
-          }
-          activeAuthorizationModule = await loadAuthorizationModule();
-          const authorizationRegistration = await registerProjectAuthorizationDefinitions(
-            projectRoot,
-            registry,
-            activeAuthorizationModule
-          );
-          runtimeOwnedAuthorizationPolicyNames.splice(0, runtimeOwnedAuthorizationPolicyNames.length, ...authorizationRegistration.policyNames);
-          runtimeOwnedAuthorizationAbilityNames.splice(0, runtimeOwnedAuthorizationAbilityNames.length, ...authorizationRegistration.abilityNames);
-          if (options.registerProjectQueueJobs !== false && registryHasJobs(registry)) {
-            if (!activeQueueModule) {
-              throw new Error("[@holo-js/core] Project jobs require @holo-js/queue to be installed.");
-            }
-            runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-            runtimeOwnedQueueJobNames.push(...await registerProjectQueueJobs(projectRoot, registry, activeQueueModule));
-          }
-        }
-        runtime.initialized = true;
-        getRuntimeState().current = runtime;
-      } catch (error) {
-        unregisterProjectEventsAndListeners(activeEventsModule, runtimeOwnedEventNames, runtimeOwnedListenerIds);
-        runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length);
-        runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length);
-        unregisterProjectAuthorizationDefinitions(activeAuthorizationModule, runtimeOwnedAuthorizationPolicyNames, runtimeOwnedAuthorizationAbilityNames);
-        runtimeOwnedAuthorizationPolicyNames.splice(0, runtimeOwnedAuthorizationPolicyNames.length);
-        runtimeOwnedAuthorizationAbilityNames.splice(0, runtimeOwnedAuthorizationAbilityNames.length);
-        unregisterProjectQueueJobs(activeQueueModule, runtimeOwnedQueueJobNames);
-        runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-        activeAuthorizationModule = void 0;
-        activeEventsModule = void 0;
-        activeQueueModule = void 0;
-        activeSessionRuntime = void 0;
-        activeAuthRuntime = void 0;
-        activeAuthContext = void 0;
-        await manager.disconnectAll().catch(() => {
-        });
-        resetDB();
-        await resetOptionalHoloSubsystems();
-        if (previousOptionalSubsystemBindings) {
-          restoreOptionalSubsystemRuntimeBindings(previousOptionalSubsystemBindings);
-        }
-        if (options.renderView) {
-          restoreHoloRenderingRuntime(previousRenderView);
-        }
-        resetConfigRuntime();
-        getRuntimeState().current = void 0;
-        throw error;
-      }
+      if (runtime.initialized) throw new Error("Holo runtime is already initialized.");
+      if (getRuntimeState().current) throw new Error("A Holo runtime is already initialized for this process.");
+      await runtimeLifecycle.initialize({ projectRoot });
+      runtime.initialized = true;
+      getRuntimeState().current = runtime;
     },
     async shutdown() {
-      try {
-        if (runtime.initialized) {
-          await manager.disconnectAll();
-        }
-      } finally {
-        runtime.initialized = false;
-        if (getRuntimeState().current === runtime) {
-          getRuntimeState().current = void 0;
-        }
-        unregisterProjectEventsAndListeners(activeEventsModule, runtimeOwnedEventNames, runtimeOwnedListenerIds);
-        runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length);
-        runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length);
-        unregisterProjectAuthorizationDefinitions(activeAuthorizationModule, runtimeOwnedAuthorizationPolicyNames, runtimeOwnedAuthorizationAbilityNames);
-        runtimeOwnedAuthorizationPolicyNames.splice(0, runtimeOwnedAuthorizationPolicyNames.length);
-        runtimeOwnedAuthorizationAbilityNames.splice(0, runtimeOwnedAuthorizationAbilityNames.length);
-        unregisterProjectQueueJobs(activeQueueModule, runtimeOwnedQueueJobNames);
-        runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-        activeAuthorizationModule = void 0;
-        activeEventsModule = void 0;
-        activeQueueModule = void 0;
-        activeSessionRuntime = void 0;
-        activeAuthRuntime = void 0;
-        activeAuthContext = void 0;
-        resetDB();
-        await resetOptionalHoloSubsystems();
-        if (previousOptionalSubsystemBindings) {
-          restoreOptionalSubsystemRuntimeBindings(previousOptionalSubsystemBindings);
-        }
-        if (options.renderView) {
-          restoreHoloRenderingRuntime(previousRenderView);
-        }
-        resetConfigRuntime();
-      }
+      runtime.initialized = false;
+      if (getRuntimeState().current === runtime) getRuntimeState().current = void 0;
+      await runtimeLifecycle.dispose({ projectRoot });
     }
   };
   return runtime;
 }
 async function initializeHolo(projectRoot, options = {}) {
   const state = getRuntimeState();
-  const resolvedProjectRoot = resolve3(projectRoot);
+  const resolvedProjectRoot = resolve5(projectRoot);
   const current = state.current;
   if (current) {
-    if (resolve3(current.projectRoot) !== resolvedProjectRoot) {
+    if (resolve5(current.projectRoot) !== resolvedProjectRoot) {
       throw new Error(`A Holo runtime is already initialized for "${current.projectRoot}".`);
     }
     ;
@@ -2768,7 +2959,7 @@ async function initializeHolo(projectRoot, options = {}) {
     return current;
   }
   if (state.pending) {
-    if (state.pendingProjectRoot && resolve3(state.pendingProjectRoot) !== resolvedProjectRoot) {
+    if (state.pendingProjectRoot && resolve5(state.pendingProjectRoot) !== resolvedProjectRoot) {
       throw new Error(`A Holo runtime is already initializing for "${state.pendingProjectRoot}".`);
     }
     return state.pending.then((runtime) => {
@@ -2801,7 +2992,7 @@ async function ensureHolo(projectRoot, options = {}) {
   if (!current) {
     return initializeHolo(projectRoot, options);
   }
-  if (resolve3(current.projectRoot) !== resolve3(projectRoot)) {
+  if (resolve5(current.projectRoot) !== resolve5(projectRoot)) {
     throw new Error(`A Holo runtime is already initialized for "${current.projectRoot}".`);
   }
   return current;