@holo-js/core 0.1.0

package/dist/chunk-SVCNZBIQ.mjs

@@ -0,0 +1,703 @@
+// 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
+};

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { GeneratedProjectRegistry, HoloRuntime, CreateHoloOptions } from './runtime/index.js';
+export { createHolo, ensureHolo, getHolo, holoRuntimeInternals, initializeHolo, loadGeneratedProjectRegistry, peekHolo, registryInternals, resetHoloRuntime, resolveGeneratedProjectRegistryPath } from './runtime/index.js';
+import { HoloConfigMap, LoadedHoloConfig, DotPath, ValueAtPath } from '@holo-js/config';
+export { createRuntimeConnectionOptions, resolveRuntimeConnectionManagerOptions } from '@holo-js/db';
+import '@holo-js/queue';
+
+declare function resolveStorageKeyPath(root: string, key: string): string;
+
+interface HoloAdapterProject<TCustom extends HoloConfigMap = HoloConfigMap> {
+    readonly projectRoot: string;
+    readonly config: LoadedHoloConfig<TCustom>;
+    readonly registry?: GeneratedProjectRegistry;
+    readonly runtime: HoloRuntime<TCustom>;
+}
+interface HoloFrameworkOptions extends CreateHoloOptions {
+    readonly projectRoot?: string;
+}
+interface ResolvedHoloFrameworkOptions {
+    readonly projectRoot: string;
+    readonly runtime: CreateHoloOptions;
+}
+interface HoloAdapterProjectAccessors<TCustom extends HoloConfigMap = HoloConfigMap> {
+    getApp(): Promise<HoloAdapterProject<TCustom>>;
+    getProject(): Promise<HoloAdapterProject<TCustom>>;
+    useConfig<TKey extends Extract<keyof LoadedHoloConfig<TCustom>['all'], string>>(key: TKey): Promise<LoadedHoloConfig<TCustom>['all'][TKey]>;
+    useConfig<TPath extends DotPath<LoadedHoloConfig<TCustom>['all']>>(path: TPath): Promise<ValueAtPath<LoadedHoloConfig<TCustom>['all'], TPath>>;
+    config<TPath extends DotPath<LoadedHoloConfig<TCustom>['all']>>(path: TPath): Promise<ValueAtPath<LoadedHoloConfig<TCustom>['all'], TPath>>;
+}
+interface HoloFrameworkAdapterState<TProject extends HoloAdapterProject = HoloAdapterProject> {
+    readonly projectRoot?: string;
+    readonly project?: TProject;
+    readonly sourceSignature?: string;
+}
+interface HoloAdapterCapabilities {
+    readonly config: 'layered-env-and-cache';
+    readonly discovery: 'generated-registries';
+    readonly runtime: 'singleton-runtime';
+    readonly requestContext: 'typed-project-accessors';
+    readonly typing: 'inferred-file-and-dot-config';
+    readonly rendering: 'framework-owned';
+    readonly hosting: 'runtime-agnostic';
+}
+declare const HOLO_MINIMUM_ADAPTER_CAPABILITIES: Readonly<HoloAdapterCapabilities>;
+declare function defineHoloAdapterCapabilities<TCapabilities extends HoloAdapterCapabilities>(capabilities: TCapabilities): Readonly<TCapabilities>;
+declare function resolveHoloFrameworkOptions(options?: HoloFrameworkOptions): ResolvedHoloFrameworkOptions;
+declare function createHoloProjectAccessors<TCustom extends HoloConfigMap = HoloConfigMap>(resolveProject: () => Promise<HoloAdapterProject<TCustom>>): HoloAdapterProjectAccessors<TCustom>;
+declare function resetSingletonFrameworkProject(stateKey: string): Promise<void>;
+interface CreateHoloFrameworkAdapterOptions {
+    readonly stateKey: string;
+    readonly displayName: string;
+    readonly capabilities?: HoloAdapterCapabilities;
+}
+declare function createHoloFrameworkAdapter<TOptions extends HoloFrameworkOptions = HoloFrameworkOptions>(options: CreateHoloFrameworkAdapterOptions): {
+    capabilities: Readonly<HoloAdapterCapabilities>;
+    createProject: <TCustom extends HoloConfigMap = object>(projectOptions?: TOptions) => Promise<HoloAdapterProject<TCustom>>;
+    initializeProject: <TCustom extends HoloConfigMap = object>(projectOptions?: TOptions) => Promise<HoloAdapterProject<TCustom>>;
+    createHelpers: <TCustom extends HoloConfigMap = object>(projectOptions?: TOptions) => HoloAdapterProjectAccessors<TCustom>;
+    resetProject: () => Promise<void>;
+    internals: {
+        getState: () => HoloFrameworkAdapterState<HoloAdapterProject<object>>;
+        resolveOptions: (projectOptions?: TOptions) => ResolvedHoloFrameworkOptions;
+    };
+};
+declare function createHoloAdapterProject<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloAdapterProject<TCustom>>;
+declare function initializeHoloAdapterProject<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloAdapterProject<TCustom>>;
+declare const adapterInternals: {
+    resolveStorageKeyPath: typeof resolveStorageKeyPath;
+};
+
+export { type CreateHoloFrameworkAdapterOptions, CreateHoloOptions, HOLO_MINIMUM_ADAPTER_CAPABILITIES, type HoloAdapterCapabilities, type HoloAdapterProject, type HoloAdapterProjectAccessors, type HoloFrameworkAdapterState, type HoloFrameworkOptions, HoloRuntime, type ResolvedHoloFrameworkOptions, adapterInternals, createHoloAdapterProject, createHoloFrameworkAdapter, createHoloProjectAccessors, defineHoloAdapterCapabilities, initializeHoloAdapterProject, resetSingletonFrameworkProject, resolveHoloFrameworkOptions };

package/dist/index.mjs

@@ -0,0 +1,235 @@
+import {
+  configurePlainNodeStorageRuntime,
+  createHolo,
+  createRuntimeConnectionOptions,
+  ensureHolo,
+  getHolo,
+  holoRuntimeInternals,
+  initializeHolo,
+  loadGeneratedProjectRegistry,
+  peekHolo,
+  registryInternals,
+  resetHoloRuntime,
+  resolveGeneratedProjectRegistryPath,
+  resolveRuntimeConnectionManagerOptions,
+  resolveStorageKeyPath
+} from "./chunk-SVCNZBIQ.mjs";
+
+// src/adapter.ts
+import { readdir, stat } from "fs/promises";
+import { extname, join, resolve } from "path";
+import { configureConfigRuntime, resolveEnvironmentFileOrder } from "@holo-js/config";
+import { configureDB } from "@holo-js/db";
+import { configureQueueRuntime } from "@holo-js/queue";
+import { createQueueDbRuntimeOptions } from "@holo-js/queue-db";
+import {
+  resetStorageRuntime
+} from "@holo-js/storage/runtime";
+var HOLO_MINIMUM_ADAPTER_CAPABILITIES = Object.freeze({
+  config: "layered-env-and-cache",
+  discovery: "generated-registries",
+  runtime: "singleton-runtime",
+  requestContext: "typed-project-accessors",
+  typing: "inferred-file-and-dot-config",
+  rendering: "framework-owned",
+  hosting: "runtime-agnostic"
+});
+function defineHoloAdapterCapabilities(capabilities) {
+  return Object.freeze({ ...capabilities });
+}
+function getFrameworkAdapterStateContainer(stateKey) {
+  const runtime = globalThis;
+  runtime.__holoFrameworkAdapters__ ??= {};
+  runtime.__holoFrameworkAdapters__[stateKey] ??= {};
+  return runtime.__holoFrameworkAdapters__[stateKey];
+}
+async function resolveFileStamp(filePath) {
+  try {
+    const metadata = await stat(filePath);
+    return `${filePath}:${metadata.size}:${metadata.mtimeMs}`;
+  } catch {
+    return `${filePath}:missing`;
+  }
+}
+var CONFIG_EXTENSION_PRIORITY = [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"];
+var SUPPORTED_CONFIG_EXTENSIONS = new Set(CONFIG_EXTENSION_PRIORITY);
+async function resolveConfigDirectoryStamp(projectRoot) {
+  const configDir = resolve(projectRoot, "config");
+  const entries = await readdir(configDir, { withFileTypes: true }).catch(() => []);
+  const files = entries.filter((entry) => entry.isFile() && SUPPORTED_CONFIG_EXTENSIONS.has(extname(entry.name))).map((entry) => join(configDir, entry.name)).sort((left, right) => left.localeCompare(right));
+  const stamps = await Promise.all(files.map(resolveFileStamp));
+  return stamps.join("|");
+}
+async function resolveProjectSourceSignature(projectRoot, envName) {
+  const registryStamp = await resolveFileStamp(resolve(projectRoot, ".holo-js/generated/registry.json"));
+  const envFiles = resolveEnvironmentFileOrder(envName).map((relativeName) => resolve(projectRoot, relativeName));
+  const envStamps = await Promise.all(envFiles.map(resolveFileStamp));
+  const configStamp = await resolveConfigDirectoryStamp(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot);
+  const jobStamps = await Promise.all((registry?.jobs ?? []).map((entry) => resolveFileStamp(resolve(projectRoot, entry.sourcePath))));
+  const eventStamps = await Promise.all((registry?.events ?? []).map((entry) => resolveFileStamp(resolve(projectRoot, entry.sourcePath))));
+  const listenerStamps = await Promise.all((registry?.listeners ?? []).map((entry) => resolveFileStamp(resolve(projectRoot, entry.sourcePath))));
+  return [configStamp, registryStamp, ...envStamps, ...jobStamps, ...eventStamps, ...listenerStamps].join("||");
+}
+function resolveHoloFrameworkOptions(options = {}) {
+  const processEnv = options.processEnv ?? process.env;
+  return {
+    projectRoot: resolve(options.projectRoot ?? process.cwd()),
+    runtime: {
+      envName: options.envName,
+      preferCache: options.preferCache ?? processEnv.NODE_ENV === "production",
+      processEnv,
+      registerProjectQueueJobs: options.registerProjectQueueJobs
+    }
+  };
+}
+function createHoloProjectAccessors(resolveProject) {
+  const useConfig = (async (path) => {
+    const project = await resolveProject();
+    return project.runtime.useConfig(path);
+  });
+  return {
+    getApp: resolveProject,
+    getProject: resolveProject,
+    useConfig,
+    async config(path) {
+      const project = await resolveProject();
+      return project.runtime.config(path);
+    }
+  };
+}
+async function initializeSingletonFrameworkProject(stateKey, displayName, options, createProject) {
+  const resolved = resolveHoloFrameworkOptions(options);
+  const state = getFrameworkAdapterStateContainer(stateKey);
+  if (state.project) {
+    if (state.projectRoot !== resolved.projectRoot) {
+      throw new Error(`${displayName} Holo project already initialized for "${state.projectRoot}".`);
+    }
+    const currentRuntime = peekHolo();
+    if (currentRuntime && resolve(currentRuntime.projectRoot) === resolved.projectRoot) {
+      if (resolved.runtime.preferCache === false) {
+        const currentSignature = await resolveProjectSourceSignature(
+          resolved.projectRoot,
+          currentRuntime.loadedConfig.environment.name
+        );
+        if (state.sourceSignature && state.sourceSignature !== currentSignature) {
+          await currentRuntime.shutdown();
+          state.project = void 0;
+          state.projectRoot = void 0;
+          state.sourceSignature = void 0;
+        }
+      }
+      if (!state.project) {
+        return initializeSingletonFrameworkProject(stateKey, displayName, options, createProject);
+      }
+      configureConfigRuntime(currentRuntime.loadedConfig.all);
+      configureDB(currentRuntime.manager);
+      configureQueueRuntime({
+        config: currentRuntime.loadedConfig.queue,
+        ...createQueueDbRuntimeOptions()
+      });
+      configurePlainNodeStorageRuntime(state.project.projectRoot, currentRuntime.loadedConfig);
+      if (state.project.runtime !== currentRuntime) {
+        ;
+        state.project = {
+          ...state.project,
+          config: currentRuntime.loadedConfig,
+          registry: currentRuntime.registry,
+          runtime: currentRuntime
+        };
+      }
+      return state.project;
+    }
+    ;
+    state.project = void 0;
+  }
+  const project = await createProject(resolved);
+  state.projectRoot = resolved.projectRoot;
+  state.project = project;
+  state.sourceSignature = resolved.runtime.preferCache === false ? await resolveProjectSourceSignature(resolved.projectRoot, project.config.environment.name) : void 0;
+  return project;
+}
+async function resetSingletonFrameworkProject(stateKey) {
+  const state = getFrameworkAdapterStateContainer(stateKey);
+  state.project = void 0;
+  state.projectRoot = void 0;
+  state.sourceSignature = void 0;
+  resetStorageRuntime();
+  await resetHoloRuntime();
+}
+function createHoloFrameworkAdapter(options) {
+  const capabilities = defineHoloAdapterCapabilities(
+    options.capabilities ?? HOLO_MINIMUM_ADAPTER_CAPABILITIES
+  );
+  async function createProject(projectOptions = {}) {
+    const resolved = resolveHoloFrameworkOptions(projectOptions);
+    return createHoloAdapterProject(resolved.projectRoot, resolved.runtime);
+  }
+  async function initializeProject(projectOptions = {}) {
+    return initializeSingletonFrameworkProject(
+      options.stateKey,
+      options.displayName,
+      projectOptions,
+      async (resolved) => initializeHoloAdapterProject(resolved.projectRoot, resolved.runtime)
+    );
+  }
+  function createHelpers(projectOptions = {}) {
+    return createHoloProjectAccessors(() => initializeProject(projectOptions));
+  }
+  return {
+    capabilities,
+    createProject,
+    initializeProject,
+    createHelpers,
+    resetProject: () => resetSingletonFrameworkProject(options.stateKey),
+    internals: {
+      getState: () => getFrameworkAdapterStateContainer(options.stateKey),
+      resolveOptions: (projectOptions = {}) => resolveHoloFrameworkOptions(projectOptions)
+    }
+  };
+}
+async function createHoloAdapterProject(projectRoot, options = {}) {
+  const runtime = await createHolo(projectRoot, options);
+  const project = {
+    projectRoot: runtime.projectRoot,
+    config: runtime.loadedConfig,
+    registry: runtime.registry,
+    runtime
+  };
+  return project;
+}
+async function initializeHoloAdapterProject(projectRoot, options = {}) {
+  const project = await createHoloAdapterProject(projectRoot, options);
+  const runtime = await ensureHolo(project.projectRoot, options);
+  configurePlainNodeStorageRuntime(project.projectRoot, runtime.loadedConfig);
+  return {
+    ...project,
+    runtime
+  };
+}
+var adapterInternals = {
+  resolveStorageKeyPath
+};
+export {
+  HOLO_MINIMUM_ADAPTER_CAPABILITIES,
+  adapterInternals,
+  createHolo,
+  createHoloAdapterProject,
+  createHoloFrameworkAdapter,
+  createHoloProjectAccessors,
+  createRuntimeConnectionOptions,
+  defineHoloAdapterCapabilities,
+  ensureHolo,
+  getHolo,
+  holoRuntimeInternals,
+  initializeHolo,
+  initializeHoloAdapterProject,
+  loadGeneratedProjectRegistry,
+  peekHolo,
+  registryInternals,
+  resetHoloRuntime,
+  resetSingletonFrameworkProject,
+  resolveGeneratedProjectRegistryPath,
+  resolveHoloFrameworkOptions,
+  resolveRuntimeConnectionManagerOptions
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,115 @@
+import { HoloConfigMap, LoadedHoloConfig, DotPath, ValueAtPath } from '@holo-js/config';
+import { QueueRuntimeBinding } from '@holo-js/queue';
+import { resolveRuntimeConnectionManagerOptions } from '@holo-js/db';
+export { RuntimeConfigInput, RuntimeConnectionConfig, RuntimeDatabaseConfig, RuntimeHoloConfig, SupportedDatabaseDriver, createAdapter, createDialect, createRuntimeConnectionOptions, createRuntimeLogger, isSupportedDatabaseDriver, parseDatabaseDriver, resolveRuntimeConnectionManagerOptions } from '@holo-js/db';
+
+interface GeneratedModelRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly prunable: boolean;
+}
+interface GeneratedMigrationRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+}
+interface GeneratedSeederRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+}
+interface GeneratedCommandRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly description: string;
+    readonly usage?: string;
+}
+interface GeneratedJobRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
+    readonly timeout?: number;
+}
+interface GeneratedEventRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+}
+interface GeneratedListenerRegistryEntry {
+    readonly sourcePath: string;
+    readonly id: string;
+    readonly eventNames: readonly string[];
+    readonly exportName?: string;
+}
+interface GeneratedProjectRegistry {
+    readonly version: 1;
+    readonly generatedAt: string;
+    readonly paths: {
+        readonly models: string;
+        readonly migrations: string;
+        readonly seeders: string;
+        readonly commands: string;
+        readonly jobs: string;
+        readonly events: string;
+        readonly listeners: string;
+        readonly generatedSchema: string;
+    };
+    readonly models: readonly GeneratedModelRegistryEntry[];
+    readonly migrations: readonly GeneratedMigrationRegistryEntry[];
+    readonly seeders: readonly GeneratedSeederRegistryEntry[];
+    readonly commands: readonly GeneratedCommandRegistryEntry[];
+    readonly jobs: readonly GeneratedJobRegistryEntry[];
+    readonly events: readonly GeneratedEventRegistryEntry[];
+    readonly listeners: readonly GeneratedListenerRegistryEntry[];
+}
+declare function normalizeLegacyGeneratedProjectRegistry(value: Record<string, unknown>): void;
+declare function isGeneratedProjectRegistry(value: unknown): value is GeneratedProjectRegistry;
+declare function resolveGeneratedProjectRegistryPath(projectRoot: string): string;
+declare function loadGeneratedProjectRegistry(projectRoot: string): Promise<GeneratedProjectRegistry | undefined>;
+declare const registryInternals: {
+    isGeneratedProjectRegistry: typeof isGeneratedProjectRegistry;
+    normalizeLegacyGeneratedProjectRegistry: typeof normalizeLegacyGeneratedProjectRegistry;
+};
+
+type RuntimeConfigRegistry<TCustom extends HoloConfigMap> = LoadedHoloConfig<TCustom>['all'];
+type PortableRuntimeConfig<TCustom extends HoloConfigMap> = {
+    readonly db: LoadedHoloConfig<TCustom>['database'];
+    readonly queue: LoadedHoloConfig<TCustom>['queue'];
+};
+type PortableConnectionManager = ReturnType<typeof resolveRuntimeConnectionManagerOptions>;
+interface CreateHoloOptions {
+    readonly envName?: string;
+    readonly preferCache?: boolean;
+    readonly processEnv?: NodeJS.ProcessEnv;
+    readonly registerProjectQueueJobs?: boolean;
+}
+interface HoloRuntime<TCustom extends HoloConfigMap = HoloConfigMap> {
+    readonly projectRoot: string;
+    readonly loadedConfig: LoadedHoloConfig<TCustom>;
+    readonly registry?: GeneratedProjectRegistry;
+    readonly manager: PortableConnectionManager;
+    readonly runtimeConfig: PortableRuntimeConfig<TCustom>;
+    readonly queue: QueueRuntimeBinding;
+    readonly initialized: boolean;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    useConfig<TKey extends Extract<keyof RuntimeConfigRegistry<TCustom>, string>>(key: TKey): RuntimeConfigRegistry<TCustom>[TKey];
+    useConfig<TPath extends DotPath<RuntimeConfigRegistry<TCustom>>>(path: TPath): ValueAtPath<RuntimeConfigRegistry<TCustom>, TPath>;
+    config<TPath extends DotPath<RuntimeConfigRegistry<TCustom>>>(path: TPath): ValueAtPath<RuntimeConfigRegistry<TCustom>, TPath>;
+}
+declare function createHolo<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloRuntime<TCustom>>;
+declare function initializeHolo<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloRuntime<TCustom>>;
+declare function peekHolo<TCustom extends HoloConfigMap = HoloConfigMap>(): HoloRuntime<TCustom> | undefined;
+declare function ensureHolo<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloRuntime<TCustom>>;
+declare function getHolo<TCustom extends HoloConfigMap = HoloConfigMap>(): HoloRuntime<TCustom>;
+declare function resetHoloRuntime(): Promise<void>;
+declare function getConfigValue(path: string): unknown;
+declare function getConfigSection(key: string): unknown;
+declare const holoRuntimeInternals: {
+    getConfigSection: typeof getConfigSection;
+    getConfigValue: typeof getConfigValue;
+};
+
+export { type CreateHoloOptions, type GeneratedCommandRegistryEntry, type GeneratedEventRegistryEntry, type GeneratedJobRegistryEntry, type GeneratedListenerRegistryEntry, type GeneratedMigrationRegistryEntry, type GeneratedModelRegistryEntry, type GeneratedProjectRegistry, type GeneratedSeederRegistryEntry, type HoloRuntime, createHolo, ensureHolo, getHolo, holoRuntimeInternals, initializeHolo, loadGeneratedProjectRegistry, peekHolo, registryInternals, resetHoloRuntime, resolveGeneratedProjectRegistryPath };

package/dist/runtime/index.mjs

@@ -0,0 +1,38 @@
+import {
+  createAdapter,
+  createDialect,
+  createHolo,
+  createRuntimeConnectionOptions,
+  createRuntimeLogger,
+  ensureHolo,
+  getHolo,
+  holoRuntimeInternals,
+  initializeHolo,
+  isSupportedDatabaseDriver,
+  loadGeneratedProjectRegistry,
+  parseDatabaseDriver,
+  peekHolo,
+  registryInternals,
+  resetHoloRuntime,
+  resolveGeneratedProjectRegistryPath,
+  resolveRuntimeConnectionManagerOptions
+} from "../chunk-SVCNZBIQ.mjs";
+export {
+  createAdapter,
+  createDialect,
+  createHolo,
+  createRuntimeConnectionOptions,
+  createRuntimeLogger,
+  ensureHolo,
+  getHolo,
+  holoRuntimeInternals,
+  initializeHolo,
+  isSupportedDatabaseDriver,
+  loadGeneratedProjectRegistry,
+  parseDatabaseDriver,
+  peekHolo,
+  registryInternals,
+  resetHoloRuntime,
+  resolveGeneratedProjectRegistryPath,
+  resolveRuntimeConnectionManagerOptions
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@holo-js/core",
+  "version": "0.1.0",
+  "description": "Holo-JS Framework - Portable runtime core",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.mjs",
+      "default": "./dist/runtime/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@holo-js/config": "workspace:*",
+    "@holo-js/db": "workspace:*",
+    "@holo-js/events": "workspace:*",
+    "@holo-js/queue": "workspace:*",
+    "@holo-js/queue-db": "workspace:*",
+    "@holo-js/storage": "workspace:*",
+    "esbuild": "catalog:"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}