@holo-js/cli 0.2.6 → 0.3.0

package/dist/{chunk-KS5TWO75.mjs → chunk-EQUFFLRG.mjs}

@@ -1,21 +1,21 @@
 import {
   fileExists
-} from "./chunk-LBJAJLKU.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-VP2E62DF.mjs";
+} from "./chunk-M3IPUCTM.mjs";
 import {
   loadProjectConfig,
   resolveGeneratedSchemaPath
-} from "./chunk-YEFJBN56.mjs";
+} from "./chunk-JVLZ3SOW.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-QSVMXMTQ.mjs";
 import {
   loadGeneratedProjectRegistry
-} from "./chunk-J76GH2DR.mjs";
+} from "./chunk-R4ZYMEDU.mjs";
 import {
   CLI_RUNTIME_ROOT,
   GENERATED_SCHEMA_RUNTIME_PATH,
   bundleProjectModule
-} from "./chunk-ILU426CF.mjs";
+} from "./chunk-YACY2572.mjs";
 
 // src/runtime.ts
 import { spawn } from "child_process";

package/dist/chunk-HX6MOYBO.mjs

@@ -0,0 +1,2 @@
+// src/project.ts
+import { normalizeHoloProjectConfig } from "@holo-js/kernel";

package/dist/{chunk-YEFJBN56.mjs → chunk-JVLZ3SOW.mjs}

@@ -1,6 +1,6 @@
 import {
   loadGeneratedProjectRegistry
-} from "./chunk-J76GH2DR.mjs";
+} from "./chunk-R4ZYMEDU.mjs";
 import {
   APP_CONFIG_FILE_NAMES,
   DATABASE_CONFIG_FILE_NAMES,
@@ -8,7 +8,7 @@ import {
   isModulePackage,
   pathExists,
   resolveFirstExistingPath
-} from "./chunk-ILU426CF.mjs";
+} from "./chunk-YACY2572.mjs";
 
 // src/project/config.ts
 import { createHash } from "crypto";
@@ -18,14 +18,16 @@ import { pathToFileURL } from "url";
 import {
   loadConfigDirectory,
   holoAppDefaults,
-  holoDatabaseDefaults,
   loadEnvironment,
-  normalizeAppConfig,
-  normalizeDatabaseConfig
+  normalizeAppConfig
 } from "@holo-js/config";
 import {
   DEFAULT_HOLO_PROJECT_PATHS,
-  normalizeHoloProjectConfig,
+  normalizeHoloProjectConfig
+} from "@holo-js/kernel";
+import {
+  holoDatabaseDefaults,
+  normalizeDatabaseConfig,
   renderGeneratedSchemaPlaceholder
 } from "@holo-js/db";
 function isObject(value) {
@@ -91,7 +93,7 @@ async function importProjectConfigFile(projectRoot, filePath, environmentValues)
     const previousEnvEntries = /* @__PURE__ */ new Map();
     const importUrl = await resolveProjectConfigImportUrl(filePath, environmentValues);
     const configExtension = extname(filePath);
-    const bundled = configExtension === ".ts" || configExtension === ".mts" ? await bundleProjectModule(projectRoot, filePath) : void 0;
+    const bundled = configExtension === ".ts" || configExtension === ".mts" ? await bundleProjectModule(projectRoot, filePath, { bundleDependencies: true }) : void 0;
     const resolvedImportUrl = bundled ? `${pathToFileURL(bundled.path).href}${new URL(importUrl).search}` : importUrl;
     try {
       for (const [key, value] of Object.entries(environmentValues)) {
@@ -181,6 +183,7 @@ async function serializeProjectConfig(projectRoot, config, manifestPath) {
     url: appConfig.url,
     debug: appConfig.debug,
     env: appConfig.env,
+    plugins: appConfig.plugins,
     paths: config.paths
   }, null, 2);
   const extension = extname(manifestPath);
@@ -214,7 +217,7 @@ async function serializeDatabaseConfig(projectRoot, _targetPath) {
     connections: databaseConfig.connections
   }, null, 2);
   return [
-    "import { defineDatabaseConfig } from '@holo-js/config'",
+    "import { defineDatabaseConfig } from '@holo-js/db'",
     "",
     "export default defineDatabaseConfig(",
     contents,

package/dist/{chunk-4K4CWMMP.mjs → chunk-KRADH7PK.mjs}

@@ -1,23 +1,28 @@
 import {
   hasProjectDependency
-} from "./chunk-FGQ2I2YH.mjs";
+} from "./chunk-LHK5YUR4.mjs";
 import {
   prepareProjectDiscovery
-} from "./chunk-VP2E62DF.mjs";
+} from "./chunk-QSVMXMTQ.mjs";
 import {
   syncManagedDriverDependencies
-} from "./chunk-C624G3R2.mjs";
+} from "./chunk-OI54DOHK.mjs";
 import {
   ensureGeneratedSchemaPlaceholder,
   ensureProjectConfig
-} from "./chunk-YEFJBN56.mjs";
+} from "./chunk-JVLZ3SOW.mjs";
 import {
-  renderFrameworkRunner
-} from "./chunk-J76GH2DR.mjs";
+  renderFrameworkRunnerForDescriptor
+} from "./chunk-R4ZYMEDU.mjs";
 import {
+  loadProjectPluginFrameworkDescriptors
+} from "./chunk-3RFRE7XG.mjs";
+import {
+  getFrameworkDescriptorByIdFrom,
+  getFrameworkDescriptorsWith,
   readTextFile,
   writeTextFile
-} from "./chunk-ILU426CF.mjs";
+} from "./chunk-YACY2572.mjs";
 
 // src/dev.ts
 import { spawnSync, spawn } from "child_process";
@@ -137,37 +142,17 @@ async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync)
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project dependency installation failed.");
   }
 }
-var FRAMEWORK_SYNC_DEFINITIONS = [
-  {
-    framework: "nuxt",
-    commands: {
-      bun: ["bun", "x", "nuxt", "prepare"],
-      npm: ["npm", "exec", "--", "nuxt", "prepare"],
-      pnpm: ["pnpm", "exec", "nuxt", "prepare"],
-      yarn: ["yarn", "run", "nuxt", "prepare"]
-    },
-    errorLabel: "nuxt prepare"
-  },
-  {
-    framework: "sveltekit",
-    commands: {
-      bun: ["bun", "x", "svelte-kit", "sync"],
-      npm: ["npm", "exec", "--", "svelte-kit", "sync"],
-      pnpm: ["pnpm", "exec", "svelte-kit", "sync"],
-      yarn: ["yarn", "run", "svelte-kit", "sync"]
-    },
-    errorLabel: "svelte-kit sync"
-  }
-];
 async function runProjectPrepare(projectRoot, io, options = {}) {
   const project = await ensureProjectConfig(projectRoot);
   await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
   await prepareProjectDiscovery(projectRoot, project.config);
   await refreshFrameworkRunner(projectRoot);
   const syncFramework = options.syncFramework ?? true;
+  const syncDefinitions = syncFramework ? await resolveProjectFrameworkSyncDefinitions(projectRoot) : [];
   if (syncFramework) {
-    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
-    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+    for (const definition of syncDefinitions) {
+      await runFrameworkSync(projectRoot, definition);
+    }
   }
   const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
   if (updatedDependencies && io) {
@@ -175,8 +160,9 @@ async function runProjectPrepare(projectRoot, io, options = {}) {
     await prepareProjectDiscovery(projectRoot, project.config);
     await refreshFrameworkRunner(projectRoot);
     if (syncFramework) {
-      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
-      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+      for (const definition of syncDefinitions) {
+        await runFrameworkSync(projectRoot, definition);
+      }
     }
   }
 }
@@ -186,35 +172,53 @@ async function runProjectHotPrepare(projectRoot, io) {
 async function refreshFrameworkRunner(projectRoot) {
   const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
   const frameworkRunnerPath = resolve(projectRoot, ".holo-js/framework/run.mjs");
-  const framework = await resolveProjectFramework(projectRoot, frameworkProjectPath);
-  if (!framework) {
+  const descriptor = await resolveProjectFramework(projectRoot, frameworkProjectPath);
+  if (!descriptor) {
     return;
   }
-  await writeTextFile(frameworkProjectPath, `${JSON.stringify({ framework }, null, 2)}
+  await writeTextFile(frameworkProjectPath, `${JSON.stringify({ framework: descriptor.id }, null, 2)}
 `);
-  await writeTextFile(frameworkRunnerPath, renderFrameworkRunner({ framework }));
+  await writeTextFile(frameworkRunnerPath, renderFrameworkRunnerForDescriptor(descriptor));
 }
 async function resolveProjectFramework(projectRoot, frameworkProjectPath) {
+  const pluginDescriptors = await loadProjectPluginFrameworkDescriptors(projectRoot);
   try {
     const content = await readFile(frameworkProjectPath, "utf8");
     const manifest = JSON.parse(content);
-    if (manifest.framework !== "next" && manifest.framework !== "nuxt" && manifest.framework !== "sveltekit") {
-      return;
-    }
-    return manifest.framework;
+    const descriptor = typeof manifest.framework === "string" ? getFrameworkDescriptorByIdFrom(manifest.framework, pluginDescriptors) : void 0;
+    return descriptor ?? resolveProjectFrameworkFromDependencies(projectRoot, pluginDescriptors);
   } catch {
+    return resolveProjectFrameworkFromDependencies(projectRoot, pluginDescriptors);
   }
-  if (await hasProjectDependency(projectRoot, "next")) {
-    return "next";
-  }
-  if (await hasProjectDependency(projectRoot, "nuxt")) {
-    return "nuxt";
-  }
-  if (await hasProjectDependency(projectRoot, "@sveltejs/kit")) {
-    return "sveltekit";
+}
+async function resolveProjectFrameworkFromDependencies(projectRoot, pluginDescriptors = []) {
+  for (const descriptor of getFrameworkDescriptorsWith(pluginDescriptors)) {
+    const matches = await Promise.all(
+      descriptor.detectPackages.map((packageName) => hasProjectDependency(projectRoot, packageName))
+    );
+    if (matches.some(Boolean)) {
+      return descriptor;
+    }
   }
   return void 0;
 }
+async function resolveProjectFrameworkSyncDefinitions(projectRoot) {
+  const pluginDescriptors = await loadProjectPluginFrameworkDescriptors(projectRoot);
+  const seen = /* @__PURE__ */ new Set();
+  const definitions = [];
+  for (const descriptor of getFrameworkDescriptorsWith(pluginDescriptors)) {
+    if (!descriptor.sync || seen.has(descriptor.id)) {
+      continue;
+    }
+    seen.add(descriptor.id);
+    definitions.push({
+      framework: descriptor.id,
+      commands: descriptor.sync.commands,
+      errorLabel: descriptor.sync.errorLabel
+    });
+  }
+  return Object.freeze(definitions);
+}
 async function runFrameworkSync(projectRoot, definition) {
   const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
   try {

package/dist/chunk-LALDNNPH.mjs

@@ -0,0 +1,428 @@
+import {
+  fileExists
+} from "./chunk-M3IPUCTM.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-QSVMXMTQ.mjs";
+import {
+  loadProjectConfig,
+  resolveGeneratedSchemaPath
+} from "./chunk-JVLZ3SOW.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-R4ZYMEDU.mjs";
+import {
+  CLI_RUNTIME_ROOT,
+  GENERATED_SCHEMA_RUNTIME_PATH,
+  bundleProjectModule
+} from "./chunk-YACY2572.mjs";
+
+// src/runtime.ts
+import { spawn } from "child_process";
+import { mkdir, readFile, rm, symlink, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { setTimeout } from "timers/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+import { writeConfigCache } from "@holo-js/config";
+var runtimeImportMeta = import.meta;
+var RUNTIME_DEPENDENCY_LOCK_RETRY_MS = 10;
+function resolveConfigModuleUrl(runtimeResolve = runtimeImportMeta.resolve?.bind(runtimeImportMeta)) {
+  if (typeof runtimeResolve === "function") {
+    const resolved = runtimeResolve("@holo-js/config");
+    if (resolved.startsWith("file://")) {
+      const resolvedPath = fileURLToPath(resolved);
+      const normalized = resolvedPath.replace(/\\/g, "/");
+      if (normalized.endsWith("/src/index.ts") || normalized.endsWith("/src/index.mts") || normalized.endsWith("/src/index.js") || normalized.endsWith("/src/index.mjs")) {
+        return pathToFileURL(resolve(dirname(dirname(resolvedPath)), "dist/index.mjs")).href;
+      }
+    }
+    return resolved;
+  }
+  return pathToFileURL(resolve(dirname(fileURLToPath(import.meta.url)), "../node_modules/@holo-js/config/dist/index.mjs")).href;
+}
+async function initializeProjectRuntime(projectRoot, options = {}) {
+  const { initializeHolo } = await import("@holo-js/core");
+  return initializeHolo(projectRoot, options);
+}
+function parseBooleanEnv(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+async function cacheProjectConfig(projectRoot, cacheWriter = writeConfigCache) {
+  try {
+    return await cacheWriter(projectRoot, { processEnv: process.env });
+  } catch (error) {
+    throw new Error(error instanceof Error && error.message ? error.message : "Failed to cache config.");
+  }
+}
+function createEnvRuntimeConfig() {
+  return {
+    db: {
+      defaultConnection: "default",
+      connections: {
+        default: {
+          driver: process.env.DB_DRIVER,
+          url: process.env.DB_URL,
+          host: process.env.DB_HOST,
+          port: process.env.DB_PORT,
+          username: process.env.DB_USERNAME,
+          password: process.env.DB_PASSWORD,
+          database: process.env.DB_DATABASE,
+          schema: process.env.DB_SCHEMA,
+          ssl: parseBooleanEnv(process.env.DB_SSL),
+          logging: parseBooleanEnv(process.env.DB_LOGGING)
+        }
+      }
+    }
+  };
+}
+function normalizeRuntimeConnectionInput(connection) {
+  if (typeof connection === "string") {
+    return { url: connection };
+  }
+  return connection ? { ...connection } : {};
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+function filterDefinedRuntimeConnectionInput(connection) {
+  return Object.fromEntries(
+    Object.entries(connection).filter(([, value]) => isDefined(value))
+  );
+}
+function mergeRuntimeDatabaseConfig(config, envRuntimeConfig) {
+  const envDefault = envRuntimeConfig.db.connections.default;
+  const hasEnvOverrides = Object.values(envDefault).some(isDefined);
+  if (!config) {
+    return envRuntimeConfig.db;
+  }
+  if (!hasEnvOverrides) {
+    return config;
+  }
+  const defaultConnection = config.defaultConnection ?? "default";
+  const connections = { ...config.connections ?? {} };
+  connections[defaultConnection] = {
+    ...normalizeRuntimeConnectionInput(connections[defaultConnection]),
+    ...filterDefinedRuntimeConnectionInput(envDefault)
+  };
+  return {
+    ...config,
+    defaultConnection,
+    connections
+  };
+}
+var RUNTIME_MIGRATION_NAME_PATTERN = /^\d{4}_\d{2}_\d{2}_\d{6}_[a-z0-9_]+$/;
+function inferRuntimeMigrationName(entry) {
+  const fileName = entry.split("/").pop()?.replace(/\.[^.]+$/, "");
+  if (!fileName || !RUNTIME_MIGRATION_NAME_PATTERN.test(fileName)) {
+    throw new Error(`Registered migration "${entry}" must use a timestamped file name matching YYYY_MM_DD_HHMMSS_description.`);
+  }
+  return fileName;
+}
+function normalizeRuntimeMigration(entry, migration) {
+  return {
+    ...migration,
+    name: typeof migration.name === "string" ? migration.name : inferRuntimeMigrationName(entry)
+  };
+}
+function compileFreshDropIdentifierPath(quoteIdentifier, identifier) {
+  if (!identifier.includes(".")) {
+    return quoteIdentifier(identifier);
+  }
+  return identifier.split(".").map((part) => quoteIdentifier(part)).join(".");
+}
+async function dropAllTablesForFresh(connection, schema) {
+  const tables = await schema.getTables();
+  if (connection.getDialect().name === "postgres") {
+    const schemaName = connection.getSchemaName();
+    const quoteIdentifier = connection.getDialect().quoteIdentifier;
+    for (const tableName of tables) {
+      const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+      await connection.executeCompiled({
+        sql: `DROP TABLE IF EXISTS ${compileFreshDropIdentifierPath(quoteIdentifier, qualifiedTableName)} CASCADE`,
+        source: `schema:dropTableFresh:${qualifiedTableName}`
+      });
+    }
+    return;
+  }
+  await schema.withoutForeignKeyConstraints(async () => {
+    for (const tableName of tables) {
+      await schema.dropTable(tableName);
+    }
+  });
+}
+async function getRuntimeEnvironment(projectRoot) {
+  let project = await loadProjectConfig(projectRoot, { required: true });
+  if (!await loadGeneratedProjectRegistry(projectRoot)) {
+    await prepareProjectDiscovery(projectRoot, project.config);
+    project = await loadProjectConfig(projectRoot, { required: true });
+  }
+  const generatedSchemaPath = resolveGeneratedSchemaPath(projectRoot, project.config);
+  const hasGeneratedSchema = await fileExists(generatedSchemaPath);
+  const bundleInputs = [
+    ...project.config.models.map((entry) => resolve(projectRoot, entry)),
+    ...project.config.migrations.map((entry) => resolve(projectRoot, entry)),
+    ...project.config.seeders.map((entry) => resolve(projectRoot, entry)),
+    ...hasGeneratedSchema ? [generatedSchemaPath] : []
+  ];
+  const bundled = [];
+  try {
+    for (const entryPath of bundleInputs) {
+      bundled.push(await bundleProjectModule(projectRoot, entryPath, { external: ["@holo-js/db"] }));
+    }
+  } catch (error) {
+    await Promise.all(bundled.map((entry) => entry.cleanup()));
+    throw error;
+  }
+  const bundledModels = bundled.slice(0, project.config.models.length).map((entry) => entry.path);
+  const bundledMigrations = bundled.slice(project.config.models.length, project.config.models.length + project.config.migrations.length).map((entry) => entry.path);
+  const bundledSeeders = bundled.slice(project.config.models.length + project.config.migrations.length).slice(0, project.config.seeders.length).map((entry) => entry.path);
+  const bundledGeneratedSchema = hasGeneratedSchema ? bundled[project.config.models.length + project.config.migrations.length + project.config.seeders.length]?.path : void 0;
+  return {
+    project,
+    bundledModels,
+    bundledMigrations,
+    bundledSeeders,
+    ...bundledGeneratedSchema ? { bundledGeneratedSchema } : {},
+    async cleanup() {
+      await Promise.all(bundled.map((entry) => entry.cleanup()));
+    }
+  };
+}
+async function resolvePackageRootFromSpecifier(specifier) {
+  let current = dirname(fileURLToPath(import.meta.resolve(specifier)));
+  while (true) {
+    if (await fileExists(join(current, "package.json"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      throw new Error(`Could not resolve package root for "${specifier}".`);
+    }
+    current = parent;
+  }
+}
+function isFileExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function withRuntimeDependencyLock(projectRoot, callback) {
+  const runtimeRoot = join(projectRoot, CLI_RUNTIME_ROOT);
+  const lockDir = join(runtimeRoot, "node_modules.lock");
+  await mkdir(runtimeRoot, { recursive: true });
+  while (true) {
+    try {
+      await mkdir(lockDir);
+      break;
+    } catch (error) {
+      if (!isFileExistsError(error)) {
+        throw error;
+      }
+      await setTimeout(RUNTIME_DEPENDENCY_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    return await callback();
+  } finally {
+    await rm(lockDir, { recursive: true, force: true });
+  }
+}
+async function readRuntimeDependencyReferenceCount(refPath) {
+  const raw = await readFile(refPath, "utf8").catch(() => void 0);
+  const count = raw === void 0 ? 0 : Number.parseInt(raw, 10);
+  return Number.isFinite(count) && count > 0 ? count : 0;
+}
+async function ensureRuntimeDependencyLink(projectRoot) {
+  return await withRuntimeDependencyLock(projectRoot, async () => {
+    const runtimeRoot = join(projectRoot, CLI_RUNTIME_ROOT);
+    const packageRoot = await resolvePackageRootFromSpecifier("@holo-js/db");
+    const nodeModulesDir = join(runtimeRoot, "node_modules");
+    const namespaceDir = join(nodeModulesDir, "@holo-js");
+    const targetPath = join(namespaceDir, "db");
+    const refPath = join(nodeModulesDir, ".holo-js-runtime-refs");
+    const references = await readRuntimeDependencyReferenceCount(refPath);
+    await mkdir(namespaceDir, { recursive: true });
+    if (references === 0) {
+      await rm(targetPath, { recursive: true, force: true });
+      await symlink(packageRoot, targetPath, "junction");
+    }
+    await writeFile(refPath, String(references + 1), "utf8");
+    return runtimeRoot;
+  });
+}
+async function cleanupRuntimeDependencyLink(projectRoot) {
+  await withRuntimeDependencyLock(projectRoot, async () => {
+    const nodeModulesDir = join(projectRoot, CLI_RUNTIME_ROOT, "node_modules");
+    const refPath = join(nodeModulesDir, ".holo-js-runtime-refs");
+    const references = await readRuntimeDependencyReferenceCount(refPath);
+    const nextReferences = references - 1;
+    if (nextReferences <= 0) {
+      await rm(nodeModulesDir, { recursive: true, force: true });
+      return;
+    }
+    await writeFile(refPath, String(nextReferences), "utf8");
+  });
+}
+function resolveRuntimeWorkerPath() {
+  const runtimePath = fileURLToPath(import.meta.url);
+  return runtimePath.endsWith("/src/runtime.ts") ? resolve(dirname(runtimePath), "runtime-worker.ts") : resolve(dirname(runtimePath), "runtime-worker.mjs");
+}
+function supportsNodeTypeStripping(version = process.versions.node) {
+  const [major = "0", minor = "0"] = version.split(".");
+  const majorVersion = Number.parseInt(major, 10);
+  const minorVersion = Number.parseInt(minor, 10);
+  return majorVersion > 22 || majorVersion === 22 && minorVersion >= 6;
+}
+function resolveCompiledRuntimeWorkerPath(workerPath) {
+  return resolve(dirname(workerPath), "../dist/runtime-worker.mjs");
+}
+function createRuntimeInvocation(workerPath = resolveRuntimeWorkerPath()) {
+  if (workerPath.endsWith(".ts")) {
+    return {
+      command: "node",
+      args: supportsNodeTypeStripping() ? ["--experimental-strip-types", workerPath] : [resolveCompiledRuntimeWorkerPath(workerPath)]
+    };
+  }
+  return {
+    command: "node",
+    args: [workerPath]
+  };
+}
+function runRuntimeInvocation(command, args, options) {
+  return new Promise((resolveInvocation) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let error = null;
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (spawnError) => {
+      error = spawnError;
+    });
+    child.on("close", (status) => {
+      resolveInvocation({
+        status,
+        error,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+function getRuntimeFailureMessage(kind, result) {
+  const stderr = result.stderr?.trim();
+  if (stderr) {
+    return formatRuntimeFailureText(stderr);
+  }
+  const stdout = result.stdout?.trim();
+  if (stdout) {
+    return formatRuntimeFailureText(stdout);
+  }
+  const errorCode = result.error && "code" in result.error ? result.error.code : void 0;
+  if (typeof errorCode === "string" && errorCode.length > 0) {
+    return `Failed to launch runtime command "${kind}": ${errorCode}.`;
+  }
+  return `Runtime command "${kind}" failed.`;
+}
+function stripRuntimeErrorPrefix(line) {
+  return line.replace(/^(?:[A-Za-z][\w.]*Error|Error):\s+/, "");
+}
+function isRuntimeErrorSourceLine(line) {
+  return line.startsWith("throw ") || line.startsWith("at ") || line === "^" || /^\^+$/.test(line);
+}
+function formatRuntimeFailureText(text) {
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const friendlyLine = lines.find((line) => line.includes("Unable to ") && !isRuntimeErrorSourceLine(line));
+  if (friendlyLine) {
+    return stripRuntimeErrorPrefix(friendlyLine);
+  }
+  const errorLine = lines.find((line) => /^(?:[A-Za-z][\w.]*Error|Error):\s+/.test(line));
+  if (errorLine) {
+    return stripRuntimeErrorPrefix(errorLine);
+  }
+  return lines[0] ?? text.trim();
+}
+async function withRuntimeEnvironment(projectRoot, kind, options, callback) {
+  if (kind === "seed") {
+    const project = await loadProjectConfig(projectRoot, { required: true });
+    await prepareProjectDiscovery(projectRoot, project.config);
+  }
+  const environment = await getRuntimeEnvironment(projectRoot);
+  let dependencyLinkEnsured = false;
+  try {
+    const envRuntimeConfig = createEnvRuntimeConfig();
+    const runtimeDatabaseConfig = mergeRuntimeDatabaseConfig(
+      environment.project.config.database,
+      envRuntimeConfig
+    );
+    const runtimeRoot = await ensureRuntimeDependencyLink(projectRoot);
+    dependencyLinkEnsured = true;
+    const runtimePayload = JSON.stringify({
+      kind,
+      projectRoot,
+      runtimeConfig: {
+        db: runtimeDatabaseConfig
+      },
+      models: environment.bundledModels.map((entry) => pathToFileURL(entry).href),
+      migrations: environment.bundledMigrations.map((entry) => pathToFileURL(entry).href),
+      seeders: environment.bundledSeeders.map((entry) => pathToFileURL(entry).href),
+      generatedSchema: environment.bundledGeneratedSchema ? pathToFileURL(environment.bundledGeneratedSchema).href : void 0,
+      generatedSchemaOutputPath: resolveGeneratedSchemaPath(projectRoot, environment.project.config),
+      generatedSchemaRuntimeOutputPath: resolve(projectRoot, GENERATED_SCHEMA_RUNTIME_PATH),
+      options
+    });
+    const runtime = createRuntimeInvocation();
+    const result = await runRuntimeInvocation(runtime.command, runtime.args, {
+      cwd: runtimeRoot,
+      env: {
+        ...process.env,
+        HOLO_RUNTIME_PAYLOAD: runtimePayload
+      }
+    });
+    if (result.status !== 0) {
+      throw new Error(getRuntimeFailureMessage(kind, result));
+    }
+    return await callback((result.stdout ?? "").trim());
+  } finally {
+    if (dependencyLinkEnsured) {
+      await cleanupRuntimeDependencyLink(projectRoot);
+    }
+    await environment.cleanup();
+  }
+}
+
+export {
+  resolveConfigModuleUrl,
+  initializeProjectRuntime,
+  parseBooleanEnv,
+  cacheProjectConfig,
+  createEnvRuntimeConfig,
+  normalizeRuntimeConnectionInput,
+  isDefined,
+  filterDefinedRuntimeConnectionInput,
+  mergeRuntimeDatabaseConfig,
+  RUNTIME_MIGRATION_NAME_PATTERN,
+  inferRuntimeMigrationName,
+  normalizeRuntimeMigration,
+  compileFreshDropIdentifierPath,
+  dropAllTablesForFresh,
+  getRuntimeEnvironment,
+  resolvePackageRootFromSpecifier,
+  ensureRuntimeDependencyLink,
+  cleanupRuntimeDependencyLink,
+  resolveRuntimeWorkerPath,
+  createRuntimeInvocation,
+  runRuntimeInvocation,
+  getRuntimeFailureMessage,
+  withRuntimeEnvironment
+};