@holo-js/core 0.1.2 → 0.1.4

package/dist/chunk-SVCNZBIQ.mjs

@@ -1,703 +0,0 @@
-// src/portable/dbRuntime.ts
-import {
-  createAdapter,
-  createDialect,
-  createRuntimeConnectionOptions,
-  createRuntimeLogger,
-  isSupportedDatabaseDriver,
-  parseDatabaseDriver,
-  resolveRuntimeConnectionManagerOptions
-} from "@holo-js/db";
-
-// src/portable/registry.ts
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { DEFAULT_HOLO_PROJECT_PATHS } from "@holo-js/db";
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeLegacyGeneratedProjectRegistry(value) {
-  const paths = isRecord(value.paths) ? value.paths : void 0;
-  if (paths && typeof paths.jobs !== "string") {
-    paths.jobs = DEFAULT_HOLO_PROJECT_PATHS.jobs;
-  }
-  if (paths && typeof paths.events !== "string") {
-    paths.events = DEFAULT_HOLO_PROJECT_PATHS.events;
-  }
-  if (paths && typeof paths.listeners !== "string") {
-    paths.listeners = DEFAULT_HOLO_PROJECT_PATHS.listeners;
-  }
-  if (!Array.isArray(value.jobs)) {
-    value.jobs = [];
-  }
-  if (!Array.isArray(value.events)) {
-    value.events = [];
-  }
-  if (!Array.isArray(value.listeners)) {
-    value.listeners = [];
-  }
-}
-function isGeneratedProjectRegistry(value) {
-  if (!isRecord(value)) {
-    return false;
-  }
-  normalizeLegacyGeneratedProjectRegistry(value);
-  return value.version === 1 && isRecord(value.paths) && Array.isArray(value.models) && Array.isArray(value.migrations) && Array.isArray(value.seeders) && Array.isArray(value.commands) && Array.isArray(value.jobs) && Array.isArray(value.events) && Array.isArray(value.listeners);
-}
-function resolveGeneratedProjectRegistryPath(projectRoot) {
-  return resolve(projectRoot, ".holo-js", "generated", "registry.json");
-}
-async function loadGeneratedProjectRegistry(projectRoot) {
-  const filePath = resolveGeneratedProjectRegistryPath(projectRoot);
-  const contents = await readFile(filePath, "utf8").catch(() => void 0);
-  if (!contents) {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(contents);
-    return isGeneratedProjectRegistry(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var registryInternals = {
-  isGeneratedProjectRegistry,
-  normalizeLegacyGeneratedProjectRegistry
-};
-
-// src/portable/holo.ts
-import { resolve as resolve3 } from "path";
-import {
-  config as globalConfig,
-  configureConfigRuntime,
-  createConfigAccessors,
-  loadConfigDirectory,
-  resetConfigRuntime,
-  useConfig as globalUseConfig
-} from "@holo-js/config";
-import {
-  configureDB,
-  resetDB
-} from "@holo-js/db";
-import {
-  configureQueueRuntime,
-  getRegisteredQueueJob,
-  getQueueRuntime,
-  isQueueJobDefinition,
-  normalizeQueueJobDefinition,
-  registerQueueJob,
-  shutdownQueueRuntime,
-  unregisterQueueJob
-} from "@holo-js/queue";
-import {
-  ensureEventsQueueJobRegistered,
-  getRegisteredEvent,
-  getRegisteredListener,
-  isEventDefinition,
-  isListenerDefinition,
-  normalizeListenerDefinition,
-  registerEvent,
-  registerListener,
-  unregisterEvent,
-  unregisterListener
-} from "@holo-js/events";
-import { createQueueDbRuntimeOptions } from "@holo-js/queue-db";
-import { resetStorageRuntime } from "@holo-js/storage/runtime";
-
-// src/runtimeModule.ts
-import { mkdtemp, mkdir, rm, stat, writeFile } from "fs/promises";
-import { basename, extname, join } from "path";
-import { pathToFileURL } from "url";
-var ESBUILD_MODULE_ID = "esbuild";
-async function importModule(specifier) {
-  if (process.env.VITEST) {
-    return import(
-      /* @vite-ignore */
-      specifier
-    );
-  }
-  const indirectEval = globalThis.eval;
-  return indirectEval(`import(${JSON.stringify(specifier)})`);
-}
-async function pathExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function writeLoaderTsconfig(projectRoot, tempDir) {
-  const projectTsconfigPath = join(projectRoot, "tsconfig.json");
-  if (await pathExists(projectTsconfigPath)) {
-    return projectTsconfigPath;
-  }
-  const tsconfigPath = join(tempDir, "tsconfig.json");
-  const contents = JSON.stringify({
-    compilerOptions: {
-      baseUrl: projectRoot,
-      paths: {
-        "~/*": ["./*"],
-        "@/*": ["./*"]
-      }
-    }
-  }, null, 2);
-  await writeFile(tsconfigPath, `${contents}
-`, "utf8");
-  return tsconfigPath;
-}
-async function bundleRuntimeModule(projectRoot, entryPath) {
-  const runtimeTempRoot = join(projectRoot, ".holo-js", "runtime");
-  await mkdir(runtimeTempRoot, { recursive: true });
-  const tempDir = await mkdtemp(join(runtimeTempRoot, "bundle-"));
-  const tsconfigPath = await writeLoaderTsconfig(projectRoot, tempDir);
-  const outfile = join(tempDir, `${basename(entryPath, extname(entryPath))}.mjs`);
-  const cleanup = async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  };
-  try {
-    await runtimeModuleInternals.runEsbuild({
-      absWorkingDir: projectRoot,
-      bundle: true,
-      entryPoints: [entryPath],
-      outfile,
-      format: "esm",
-      logLevel: "silent",
-      packages: "external",
-      platform: "node",
-      target: "node20",
-      tsconfig: tsconfigPath,
-      sourcemap: false
-    });
-    return {
-      path: outfile,
-      cleanup
-    };
-  } catch (error) {
-    await cleanup();
-    if (error && typeof error === "object" && Array.isArray(error.errors)) {
-      const message = error.errors.map((entry) => {
-        if (typeof entry.text === "string" && entry.text.trim()) {
-          return entry.text;
-        }
-        if (typeof entry.message === "string" && entry.message.trim()) {
-          return entry.message;
-        }
-        return "Unknown build error.";
-      }).join("\n");
-      throw new Error(message);
-    }
-    if (error instanceof Error && error.message) {
-      throw error;
-    }
-    throw new Error(`Failed to load ${entryPath}.`);
-  }
-}
-async function importBundledRuntimeModule(projectRoot, entryPath) {
-  const bundled = await bundleRuntimeModule(projectRoot, entryPath);
-  try {
-    return await runtimeModuleInternals.importModule(
-      `${pathToFileURL(bundled.path).href}?t=${Date.now()}`
-    );
-  } finally {
-    await bundled.cleanup();
-  }
-}
-async function loadEsbuild() {
-  return importModule(ESBUILD_MODULE_ID);
-}
-async function runEsbuild(options) {
-  const esbuild = await runtimeModuleInternals.loadEsbuild();
-  return esbuild.build(options);
-}
-var runtimeModuleInternals = {
-  bundleRuntimeModule,
-  importModule,
-  loadEsbuild,
-  pathExists,
-  runEsbuild,
-  writeLoaderTsconfig
-};
-
-// src/storageRuntime.ts
-import { mkdir as mkdir2, readFile as readFile2, readdir, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join2, resolve as resolve2 } from "path";
-import { normalizeModuleOptions } from "@holo-js/storage";
-import {
-  configureStorageRuntime
-} from "@holo-js/storage/runtime";
-import createS3Driver from "@holo-js/storage/runtime/drivers/s3";
-function resolveStorageKeyPath(root, key) {
-  const segments = key.split(":").filter(Boolean);
-  if (segments.includes("..")) {
-    throw new Error('[Holo Storage] Storage paths must not contain ".." segments.');
-  }
-  return resolve2(root, ...segments);
-}
-function createFileStorageBackend(root) {
-  async function listStorageKeys(currentRoot, prefix = "") {
-    const entries = await readdir(currentRoot, { withFileTypes: true }).catch(() => []);
-    const keys = [];
-    for (const entry of entries) {
-      const nextPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
-      const entryPath = join2(currentRoot, entry.name);
-      if (entry.isDirectory()) {
-        keys.push(...await listStorageKeys(entryPath, nextPrefix));
-        continue;
-      }
-      if (entry.isFile()) {
-        keys.push(nextPrefix);
-      }
-    }
-    return keys;
-  }
-  return {
-    async getItem(key) {
-      const value = await this.getItemRaw(key);
-      if (value === null) {
-        return null;
-      }
-      const serialized = Buffer.isBuffer(value) ? value.toString("utf8") : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : value instanceof ArrayBuffer ? Buffer.from(value).toString("utf8") : String(value);
-      return JSON.parse(serialized);
-    },
-    async getItemRaw(key) {
-      const targetPath = resolveStorageKeyPath(root, key);
-      try {
-        return await readFile2(targetPath);
-      } catch {
-        return null;
-      }
-    },
-    async setItem(key, value) {
-      await this.setItemRaw(key, JSON.stringify(value));
-    },
-    async setItemRaw(key, value) {
-      const targetPath = resolveStorageKeyPath(root, key);
-      await mkdir2(dirname(targetPath), { recursive: true });
-      await writeFile2(
-        targetPath,
-        value instanceof ArrayBuffer ? new Uint8Array(value) : value
-      );
-    },
-    async hasItem(key) {
-      return await this.getItemRaw(key) !== null;
-    },
-    async removeItem(key) {
-      const targetPath = resolveStorageKeyPath(root, key);
-      await rm2(targetPath, { force: true });
-      await rm2(`${targetPath}$`, { force: true });
-    },
-    async getKeys(base = "") {
-      const prefix = base.replace(/:+$/, "");
-      const keys = await listStorageKeys(root);
-      return keys.filter((key) => {
-        if (!prefix) {
-          return true;
-        }
-        return key === prefix || key.startsWith(`${prefix}:`);
-      });
-    },
-    async getMeta(key) {
-      return this.getItem(`${key}$`);
-    },
-    async setMeta(key, value) {
-      await this.setItem(`${key}$`, value);
-    },
-    async removeMeta(key) {
-      await this.removeItem(`${key}$`);
-    },
-    async clear(base = "") {
-      const prefix = base.replace(/:+$/, "");
-      const targetPath = prefix ? resolveStorageKeyPath(root, prefix) : root;
-      await rm2(targetPath, { recursive: true, force: true });
-      if (!prefix) {
-        await mkdir2(root, { recursive: true });
-      }
-    }
-  };
-}
-function createS3StorageBackend(disk) {
-  const driver = createS3Driver({
-    bucket: disk.bucket,
-    region: disk.region,
-    endpoint: disk.endpoint,
-    accessKeyId: disk.accessKeyId,
-    secretAccessKey: disk.secretAccessKey,
-    sessionToken: disk.sessionToken,
-    forcePathStyleEndpoint: disk.forcePathStyleEndpoint
-  });
-  return {
-    getItem(key) {
-      return driver.getItem(key);
-    },
-    getItemRaw: driver.getItemRaw,
-    setItem: driver.setItem,
-    setItemRaw: driver.setItemRaw,
-    hasItem: driver.hasItem,
-    removeItem: driver.removeItem,
-    getKeys: driver.getKeys,
-    getMeta(key) {
-      return driver.getMeta(key);
-    },
-    clear: driver.clear
-  };
-}
-function configurePlainNodeStorageRuntime(projectRoot, loadedConfig) {
-  const normalizedStorage = normalizeModuleOptions({
-    defaultDisk: loadedConfig.storage.defaultDisk,
-    routePrefix: loadedConfig.storage.routePrefix,
-    disks: loadedConfig.storage.disks
-  });
-  const backends = /* @__PURE__ */ new Map();
-  configureStorageRuntime({
-    getRuntimeConfig: () => ({
-      holoStorage: normalizedStorage,
-      holo: { appUrl: loadedConfig.app.url }
-    }),
-    getStorage: (base) => {
-      const diskName = base.replace(/^holo:/, "");
-      const disk = normalizedStorage.disks[diskName];
-      if (!disk) {
-        throw new Error(`[Holo Storage] Disk "${diskName}" is not configured.`);
-      }
-      const existing = backends.get(diskName);
-      if (existing) {
-        return existing;
-      }
-      const backend = disk.driver === "s3" ? createS3StorageBackend(disk) : createFileStorageBackend(
-        resolve2(projectRoot, disk.root)
-      );
-      backends.set(diskName, backend);
-      return backend;
-    }
-  });
-}
-
-// src/portable/holo.ts
-function getRuntimeState() {
-  const runtime = globalThis;
-  runtime.__holoRuntime__ ??= {};
-  return runtime.__holoRuntime__;
-}
-function resolveQueueJobExport(moduleValue) {
-  const exports = moduleValue;
-  if (isQueueJobDefinition(exports.default)) {
-    return exports.default;
-  }
-  return Object.values(exports).find((value) => isQueueJobDefinition(value));
-}
-var HOLO_EVENT_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.definition");
-var HOLO_LISTENER_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.listener");
-function hasEventDefinitionMarker(value) {
-  return !!value && typeof value === "object" && HOLO_EVENT_DEFINITION_MARKER in value;
-}
-function hasListenerDefinitionMarker(value) {
-  return !!value && typeof value === "object" && HOLO_LISTENER_DEFINITION_MARKER in value;
-}
-function resolveEventExport(moduleValue) {
-  const exports = moduleValue;
-  if (hasEventDefinitionMarker(exports.default)) {
-    return exports.default;
-  }
-  return Object.values(exports).find((value) => hasEventDefinitionMarker(value));
-}
-function resolveListenerExport(moduleValue) {
-  const exports = moduleValue;
-  if (hasListenerDefinitionMarker(exports.default) || isListenerDefinition(exports.default)) {
-    return exports.default;
-  }
-  return Object.values(exports).find((value) => hasListenerDefinitionMarker(value) || isListenerDefinition(value));
-}
-async function importRuntimeModule(projectRoot, filePath) {
-  return importBundledRuntimeModule(projectRoot, filePath);
-}
-async function registerProjectQueueJobs(projectRoot, registry) {
-  if (!registry || registry.jobs.length === 0) {
-    return Object.freeze([]);
-  }
-  const registeredJobNames = [];
-  try {
-    for (const entry of registry.jobs) {
-      const existing = getRegisteredQueueJob(entry.name);
-      if (existing && !existing.sourcePath) {
-        continue;
-      }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
-      const job = resolveQueueJobExport(moduleValue);
-      if (!job) {
-        throw new Error(`Discovered job "${entry.sourcePath}" does not export a Holo job.`);
-      }
-      registerQueueJob(normalizeQueueJobDefinition(job), {
-        name: entry.name,
-        sourcePath: entry.sourcePath,
-        replaceExisting: !!existing?.sourcePath
-      });
-      registeredJobNames.push(entry.name);
-    }
-  } catch (error) {
-    unregisterProjectQueueJobs(registeredJobNames);
-    throw error;
-  }
-  return Object.freeze(registeredJobNames);
-}
-function unregisterProjectQueueJobs(jobNames) {
-  for (const jobName of jobNames) {
-    unregisterQueueJob(jobName);
-  }
-}
-async function registerProjectEventsAndListeners(projectRoot, registry) {
-  if (!registry || registry.events.length === 0 && registry.listeners.length === 0) {
-    return Object.freeze({
-      eventNames: Object.freeze([]),
-      listenerIds: Object.freeze([])
-    });
-  }
-  const registeredEventNames = [];
-  const registeredListenerIds = [];
-  try {
-    for (const entry of registry.events) {
-      const existing = getRegisteredEvent(entry.name);
-      if (existing && !existing.sourcePath) {
-        continue;
-      }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
-      const event = resolveEventExport(moduleValue);
-      if (!event || !isEventDefinition(event)) {
-        throw new Error(`Discovered event "${entry.sourcePath}" does not export a Holo event.`);
-      }
-      registerEvent(event, {
-        name: entry.name,
-        sourcePath: entry.sourcePath,
-        replaceExisting: !!existing?.sourcePath
-      });
-      registeredEventNames.push(entry.name);
-    }
-    for (const entry of registry.listeners) {
-      const existing = getRegisteredListener(entry.id);
-      if (existing && !existing.sourcePath) {
-        continue;
-      }
-      const moduleValue = await importRuntimeModule(projectRoot, resolve3(projectRoot, entry.sourcePath));
-      const listener = resolveListenerExport(moduleValue);
-      if (!listener) {
-        throw new Error(`Discovered listener "${entry.sourcePath}" does not export a Holo listener.`);
-      }
-      const normalizedListener = normalizeListenerDefinition(listener);
-      registerListener({
-        ...normalizedListener,
-        listensTo: entry.eventNames
-      }, {
-        id: entry.id,
-        sourcePath: entry.sourcePath,
-        replaceExisting: !!existing?.sourcePath
-      });
-      registeredListenerIds.push(entry.id);
-    }
-  } catch (error) {
-    unregisterProjectEventsAndListeners(registeredEventNames, registeredListenerIds);
-    throw error;
-  }
-  return Object.freeze({
-    eventNames: Object.freeze(registeredEventNames),
-    listenerIds: Object.freeze(registeredListenerIds)
-  });
-}
-function unregisterProjectEventsAndListeners(eventNames, listenerIds) {
-  for (const listenerId of listenerIds) {
-    unregisterListener(listenerId);
-  }
-  for (const eventName of eventNames) {
-    unregisterEvent(eventName);
-  }
-}
-async function createHolo(projectRoot, options = {}) {
-  const loadedConfig = await loadConfigDirectory(projectRoot, {
-    envName: options.envName,
-    preferCache: options.preferCache,
-    processEnv: options.processEnv
-  });
-  const runtimeConfig = {
-    db: loadedConfig.database,
-    queue: loadedConfig.queue
-  };
-  const manager = resolveRuntimeConnectionManagerOptions(runtimeConfig);
-  const registry = await loadGeneratedProjectRegistry(projectRoot);
-  const accessors = createConfigAccessors(loadedConfig.all);
-  const runtimeOwnedQueueJobNames = [];
-  const runtimeOwnedEventNames = [];
-  const runtimeOwnedListenerIds = [];
-  const runtime = {
-    projectRoot,
-    loadedConfig,
-    registry,
-    manager,
-    runtimeConfig,
-    get queue() {
-      return getQueueRuntime();
-    },
-    initialized: false,
-    useConfig: accessors.useConfig,
-    config: accessors.config,
-    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);
-      try {
-        await manager.initializeAll();
-        configureQueueRuntime({
-          config: loadedConfig.queue,
-          ...createQueueDbRuntimeOptions()
-        });
-        ensureEventsQueueJobRegistered();
-        configurePlainNodeStorageRuntime(projectRoot, loadedConfig);
-        const eventRegistration = await registerProjectEventsAndListeners(projectRoot, registry);
-        runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length, ...eventRegistration.eventNames);
-        runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length, ...eventRegistration.listenerIds);
-        if (options.registerProjectQueueJobs === true) {
-          runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-          runtimeOwnedQueueJobNames.push(...await registerProjectQueueJobs(projectRoot, registry));
-        }
-        runtime.initialized = true;
-        getRuntimeState().current = runtime;
-      } catch (error) {
-        unregisterProjectEventsAndListeners(runtimeOwnedEventNames, runtimeOwnedListenerIds);
-        runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length);
-        runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length);
-        unregisterProjectQueueJobs(runtimeOwnedQueueJobNames);
-        runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-        await manager.disconnectAll().catch(() => {
-        });
-        resetDB();
-        resetStorageRuntime();
-        await shutdownQueueRuntime();
-        resetConfigRuntime();
-        getRuntimeState().current = void 0;
-        throw error;
-      }
-    },
-    async shutdown() {
-      try {
-        if (runtime.initialized) {
-          await manager.disconnectAll();
-        }
-      } finally {
-        runtime.initialized = false;
-        if (getRuntimeState().current === runtime) {
-          getRuntimeState().current = void 0;
-        }
-        unregisterProjectEventsAndListeners(runtimeOwnedEventNames, runtimeOwnedListenerIds);
-        runtimeOwnedEventNames.splice(0, runtimeOwnedEventNames.length);
-        runtimeOwnedListenerIds.splice(0, runtimeOwnedListenerIds.length);
-        unregisterProjectQueueJobs(runtimeOwnedQueueJobNames);
-        runtimeOwnedQueueJobNames.splice(0, runtimeOwnedQueueJobNames.length);
-        resetDB();
-        resetStorageRuntime();
-        await shutdownQueueRuntime();
-        resetConfigRuntime();
-      }
-    }
-  };
-  return runtime;
-}
-async function initializeHolo(projectRoot, options = {}) {
-  const state = getRuntimeState();
-  const resolvedProjectRoot = resolve3(projectRoot);
-  const current = state.current;
-  if (current) {
-    if (resolve3(current.projectRoot) !== resolvedProjectRoot) {
-      throw new Error(`A Holo runtime is already initialized for "${current.projectRoot}".`);
-    }
-    return current;
-  }
-  if (state.pending) {
-    if (state.pendingProjectRoot && resolve3(state.pendingProjectRoot) !== resolvedProjectRoot) {
-      throw new Error(`A Holo runtime is already initializing for "${state.pendingProjectRoot}".`);
-    }
-    return state.pending;
-  }
-  const pending = (async () => {
-    const runtime = await createHolo(projectRoot, options);
-    await runtime.initialize();
-    return runtime;
-  })();
-  state.pending = pending;
-  state.pendingProjectRoot = resolvedProjectRoot;
-  try {
-    return await pending;
-  } finally {
-    if (state.pending === pending) {
-      state.pending = void 0;
-      state.pendingProjectRoot = void 0;
-    }
-  }
-}
-function peekHolo() {
-  return getRuntimeState().current;
-}
-async function ensureHolo(projectRoot, options = {}) {
-  const current = peekHolo();
-  if (!current) {
-    return initializeHolo(projectRoot, options);
-  }
-  if (resolve3(current.projectRoot) !== resolve3(projectRoot)) {
-    throw new Error(`A Holo runtime is already initialized for "${current.projectRoot}".`);
-  }
-  return current;
-}
-function getHolo() {
-  const current = getRuntimeState().current;
-  if (!current) {
-    throw new Error("Holo runtime is not initialized.");
-  }
-  return current;
-}
-async function resetHoloRuntime() {
-  const current = getRuntimeState().current;
-  getRuntimeState().pending = void 0;
-  getRuntimeState().pendingProjectRoot = void 0;
-  if (!current) {
-    resetDB();
-    resetStorageRuntime();
-    await shutdownQueueRuntime();
-    resetConfigRuntime();
-    return;
-  }
-  await current.shutdown();
-}
-function getConfigValue(path) {
-  return globalConfig(path);
-}
-function getConfigSection(key) {
-  return globalUseConfig(key);
-}
-var holoRuntimeInternals = {
-  getConfigSection,
-  getConfigValue
-};
-
-export {
-  createAdapter,
-  createDialect,
-  createRuntimeConnectionOptions,
-  createRuntimeLogger,
-  isSupportedDatabaseDriver,
-  parseDatabaseDriver,
-  resolveRuntimeConnectionManagerOptions,
-  resolveGeneratedProjectRegistryPath,
-  loadGeneratedProjectRegistry,
-  registryInternals,
-  resolveStorageKeyPath,
-  configurePlainNodeStorageRuntime,
-  createHolo,
-  initializeHolo,
-  peekHolo,
-  ensureHolo,
-  getHolo,
-  resetHoloRuntime,
-  holoRuntimeInternals
-};