@holo-js/cli 0.3.0 → 0.3.1

package/dist/cache-migrations-PD2T5AV4.mjs

@@ -1,175 +0,0 @@
-import {
-  runProjectPrepare
-} from "./chunk-TH5YCOZB.mjs";
-import "./chunk-LHK5YUR4.mjs";
-import {
-  getRegistryMigrationSlug,
-  hasRegisteredCreateTableMigration,
-  hasRegisteredMigrationSlug,
-  nextMigrationTemplate
-} from "./chunk-OLZEMIDQ.mjs";
-import "./chunk-M3IPUCTM.mjs";
-import {
-  writeLine
-} from "./chunk-I7QBCEV7.mjs";
-import "./chunk-HX6MOYBO.mjs";
-import "./chunk-6BHJLCAO.mjs";
-import {
-  ensureProjectConfig
-} from "./chunk-JVLZ3SOW.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-QSVMXMTQ.mjs";
-import {
-  loadGeneratedProjectRegistry
-} from "./chunk-R4ZYMEDU.mjs";
-import "./chunk-3RFRE7XG.mjs";
-import "./chunk-TRYHX5S4.mjs";
-import {
-  makeProjectRelativePath,
-  resolveDefaultArtifactPath,
-  writeTextFile
-} from "./chunk-YACY2572.mjs";
-
-// src/cache-migrations.ts
-import { resolve } from "path";
-import {
-  CACHE_DATABASE_TABLE_DEFINITIONS,
-  DEFAULT_CACHE_DATABASE_LOCK_TABLE as CACHE_DB_DEFAULT_LOCK_TABLE,
-  DEFAULT_CACHE_DATABASE_TABLE as CACHE_DB_DEFAULT_TABLE
-} from "@holo-js/cache-db";
-import { loadConfigDirectory } from "@holo-js/config";
-import { normalizeMigrationSlug } from "@holo-js/db";
-var DEFAULT_CACHE_DATABASE_TABLE = CACHE_DB_DEFAULT_TABLE;
-var DEFAULT_CACHE_DATABASE_LOCK_TABLE = CACHE_DB_DEFAULT_LOCK_TABLE;
-async function loadCacheConfig(projectRoot) {
-  const loadedConfig = await loadConfigDirectory(projectRoot);
-  if (!loadedConfig || typeof loadedConfig !== "object" || !("cache" in loadedConfig) || !loadedConfig.cache || typeof loadedConfig.cache !== "object" || !("drivers" in loadedConfig.cache) || typeof loadedConfig.cache.drivers !== "object" || loadedConfig.cache.drivers === null || Array.isArray(loadedConfig.cache.drivers)) {
-    throw new Error("Cache config is missing or malformed. Expected a cache config object with a drivers property.");
-  }
-  const cacheConfig = loadedConfig.cache;
-  for (const [driverName, driverConfig] of Object.entries(cacheConfig.drivers)) {
-    if (driverConfig.driver !== "database") {
-      continue;
-    }
-    const databaseDriver = driverConfig;
-    if (typeof databaseDriver.table !== "string" || !databaseDriver.table.trim() || typeof databaseDriver.lockTable !== "string" || !databaseDriver.lockTable.trim()) {
-      throw new Error(`Database cache driver "${driverName}" must define non-empty "table" and "lockTable" strings.`);
-    }
-  }
-  return cacheConfig;
-}
-function normalizeCacheMigrationName(tableName) {
-  return normalizeMigrationSlug(`create_${tableName.replaceAll(".", "_")}_cache_table`);
-}
-function escapeSingleQuotedString(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
-}
-function renderCacheTableColumn(columnDefinition) {
-  const calls = [
-    `table.${columnDefinition.kind}('${escapeSingleQuotedString(columnDefinition.name)}')`
-  ];
-  if (columnDefinition.primaryKey) {
-    calls.push("primaryKey()");
-  }
-  if (columnDefinition.nullable) {
-    calls.push("nullable()");
-  }
-  return `      ${calls.join(".")}`;
-}
-function renderCacheTableCreateStatement(tableName, tableDefinition) {
-  return [
-    `    await schema.createTable('${escapeSingleQuotedString(tableName)}', (table) => {`,
-    ...tableDefinition.columns.map(renderCacheTableColumn),
-    `      table.index(['${escapeSingleQuotedString(tableDefinition.indexColumn)}'], '${escapeSingleQuotedString(tableDefinition.indexName(tableName))}')`,
-    "    })"
-  ];
-}
-function resolveCacheDatabaseTableDefinition(role) {
-  const tableDefinition = CACHE_DATABASE_TABLE_DEFINITIONS.find((definition) => definition.role === role);
-  if (!tableDefinition) {
-    throw new Error(`Missing cache database table definition for "${role}".`);
-  }
-  return tableDefinition;
-}
-function renderCacheTableMigration(tableName = DEFAULT_CACHE_DATABASE_TABLE, lockTableName = DEFAULT_CACHE_DATABASE_LOCK_TABLE) {
-  const entryTableDefinition = resolveCacheDatabaseTableDefinition("entries");
-  const lockTableDefinition = resolveCacheDatabaseTableDefinition("locks");
-  return [
-    "import { defineMigration } from '@holo-js/db'",
-    "",
-    "export default defineMigration({",
-    "  async up({ schema }) {",
-    ...renderCacheTableCreateStatement(tableName, entryTableDefinition),
-    ...renderCacheTableCreateStatement(lockTableName, lockTableDefinition),
-    "  },",
-    "  async down({ schema }) {",
-    `    await schema.dropTable('${escapeSingleQuotedString(lockTableName)}')`,
-    `    await schema.dropTable('${escapeSingleQuotedString(tableName)}')`,
-    "  },",
-    "})",
-    ""
-  ].join("\n");
-}
-function resolveDatabaseCacheTables(cacheConfig) {
-  const configured = Object.values(cacheConfig.drivers).filter((driver) => driver.driver === "database").map((driver) => ({
-    table: driver.table,
-    lockTable: driver.lockTable
-  }));
-  if (configured.length === 0) {
-    throw new Error("The configured cache drivers do not use the database driver.");
-  }
-  return Object.freeze(configured);
-}
-async function runCacheTableCommand(io, projectRoot) {
-  const project = await ensureProjectConfig(projectRoot);
-  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
-  const cacheConfig = await loadCacheConfig(projectRoot);
-  const migrationsDir = resolve(projectRoot, project.config.paths.migrations);
-  const createdFiles = [];
-  const resolvedTables = resolveDatabaseCacheTables(cacheConfig);
-  const seenPhysicalTables = /* @__PURE__ */ new Set();
-  const seenSlugs = /* @__PURE__ */ new Map();
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationName = normalizeCacheMigrationName(table);
-    const previousTable = seenSlugs.get(migrationName);
-    if (table === lockTable || seenPhysicalTables.has(table) || seenPhysicalTables.has(lockTable) || previousTable && previousTable !== table) {
-      throw new Error(`A migration for cache tables "${table}" and "${lockTable}" already exists.`);
-    }
-    seenPhysicalTables.add(table);
-    seenPhysicalTables.add(lockTable);
-    seenSlugs.set(migrationName, table);
-  }
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationName = normalizeCacheMigrationName(table);
-    if (hasRegisteredMigrationSlug(registry, migrationName) || hasRegisteredCreateTableMigration(registry, table) || hasRegisteredCreateTableMigration(registry, lockTable)) {
-      throw new Error(`A migration for cache tables "${table}" and "${lockTable}" already exists.`);
-    }
-  }
-  for (const { table, lockTable } of resolvedTables) {
-    const migrationTemplate = await nextMigrationTemplate(normalizeCacheMigrationName(table), migrationsDir);
-    const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
-    await writeTextFile(migrationFilePath, renderCacheTableMigration(table, lockTable));
-    createdFiles.push(migrationFilePath);
-  }
-  await runProjectPrepare(projectRoot);
-  for (const filePath of createdFiles) {
-    writeLine(io.stdout, `Created migration: ${makeProjectRelativePath(projectRoot, filePath)}`);
-  }
-}
-var cacheMigrationInternals = {
-  getRegistryMigrationSlug,
-  hasRegisteredMigrationSlug,
-  hasRegisteredCreateTableMigration,
-  nextMigrationTemplate
-};
-export {
-  DEFAULT_CACHE_DATABASE_LOCK_TABLE,
-  DEFAULT_CACHE_DATABASE_TABLE,
-  cacheMigrationInternals,
-  loadCacheConfig,
-  normalizeCacheMigrationName,
-  renderCacheTableMigration,
-  resolveDatabaseCacheTables,
-  runCacheTableCommand
-};

package/dist/chunk-HX6MOYBO.mjs

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

package/dist/chunk-KRADH7PK.mjs

@@ -1,501 +0,0 @@
-import {
-  hasProjectDependency
-} from "./chunk-LHK5YUR4.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-QSVMXMTQ.mjs";
-import {
-  syncManagedDriverDependencies
-} from "./chunk-OI54DOHK.mjs";
-import {
-  ensureGeneratedSchemaPlaceholder,
-  ensureProjectConfig
-} from "./chunk-JVLZ3SOW.mjs";
-import {
-  renderFrameworkRunnerForDescriptor
-} from "./chunk-R4ZYMEDU.mjs";
-import {
-  loadProjectPluginFrameworkDescriptors
-} from "./chunk-3RFRE7XG.mjs";
-import {
-  getFrameworkDescriptorByIdFrom,
-  getFrameworkDescriptorsWith,
-  readTextFile,
-  writeTextFile
-} from "./chunk-YACY2572.mjs";
-
-// src/dev.ts
-import { spawnSync, spawn } from "child_process";
-import { watch } from "fs";
-import { readdir, stat } from "fs/promises";
-import { join, dirname, relative, resolve } from "path";
-import { readFile } from "fs/promises";
-async function fileExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveProjectPackageManager(projectRoot) {
-  const packageJsonPath = join(projectRoot, "package.json");
-  const packageJson = await readTextFile(packageJsonPath);
-  if (packageJson) {
-    try {
-      const parsed = JSON.parse(packageJson);
-      const packageManager = typeof parsed.packageManager === "string" ? parsed.packageManager.split("@")[0] : void 0;
-      if (packageManager === "bun" || packageManager === "npm" || packageManager === "pnpm" || packageManager === "yarn") {
-        return packageManager;
-      }
-    } catch {
-    }
-  }
-  if (await fileExists(join(projectRoot, "bun.lock"))) {
-    return "bun";
-  }
-  if (await fileExists(join(projectRoot, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (await fileExists(join(projectRoot, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (await fileExists(join(projectRoot, "package-lock.json"))) {
-    return "npm";
-  }
-  return "bun";
-}
-async function resolvePackageManagerCommand(projectRoot, scriptName) {
-  const packageManager = await resolveProjectPackageManager(projectRoot);
-  return {
-    command: packageManager,
-    args: ["run", scriptName]
-  };
-}
-async function resolvePackageManagerInstallInvocation(projectRoot) {
-  const packageManager = await resolveProjectPackageManager(projectRoot);
-  return {
-    command: packageManager,
-    args: ["install"]
-  };
-}
-function resolveFrameworkRunnerInvocation(projectRoot, mode) {
-  return {
-    command: process.execPath,
-    args: [join(projectRoot, ".holo-js/framework/run.mjs"), mode]
-  };
-}
-async function runProjectBuild(io, projectRoot, spawn2 = spawnSync) {
-  const invocation = resolveFrameworkRunnerInvocation(projectRoot, "build");
-  const result = spawn2(invocation.command, [...invocation.args], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    env: process.env
-  });
-  if (result.stdout) {
-    io.stdout.write(result.stdout);
-  }
-  if (result.stderr) {
-    io.stderr.write(result.stderr);
-  }
-  if (result.status !== 0) {
-    throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project build failed.");
-  }
-}
-async function runProjectStartServer(io, projectRoot, spawnProcess = spawn, passthroughArgs = []) {
-  const invocation = resolveFrameworkRunnerInvocation(projectRoot, "start");
-  const child = spawnProcess(invocation.command, [...invocation.args, ...passthroughArgs], {
-    cwd: projectRoot,
-    env: process.env,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  child.stdout?.on("data", (chunk) => io.stdout.write(chunk));
-  child.stderr?.on("data", (chunk) => io.stderr.write(chunk));
-  if (child.stdin) {
-    io.stdin.pipe(child.stdin);
-  }
-  const result = await new Promise((resolvePromise) => {
-    child.on("error", (error) => resolvePromise({ kind: "error", error }));
-    child.on("close", (code) => resolvePromise({ kind: "close", code }));
-  });
-  if (result.kind === "error") {
-    throw result.error;
-  }
-  if (result.code !== 0) {
-    throw new Error(`Project production server failed with exit code ${result.code ?? "unknown"}.`);
-  }
-}
-async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync) {
-  const invocation = await resolvePackageManagerInstallInvocation(projectRoot);
-  const result = spawn2(invocation.command, [...invocation.args], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    env: process.env
-  });
-  if (result.stdout) {
-    io.stdout.write(result.stdout);
-  }
-  if (result.stderr) {
-    io.stderr.write(result.stderr);
-  }
-  if (result.status !== 0) {
-    throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project dependency installation failed.");
-  }
-}
-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) {
-    for (const definition of syncDefinitions) {
-      await runFrameworkSync(projectRoot, definition);
-    }
-  }
-  const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
-  if (updatedDependencies && io) {
-    await runProjectDependencyInstall(io, projectRoot);
-    await prepareProjectDiscovery(projectRoot, project.config);
-    await refreshFrameworkRunner(projectRoot);
-    if (syncFramework) {
-      for (const definition of syncDefinitions) {
-        await runFrameworkSync(projectRoot, definition);
-      }
-    }
-  }
-}
-async function runProjectHotPrepare(projectRoot, io) {
-  await runProjectPrepare(projectRoot, io, { syncFramework: false });
-}
-async function refreshFrameworkRunner(projectRoot) {
-  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
-  const frameworkRunnerPath = resolve(projectRoot, ".holo-js/framework/run.mjs");
-  const descriptor = await resolveProjectFramework(projectRoot, frameworkProjectPath);
-  if (!descriptor) {
-    return;
-  }
-  await writeTextFile(frameworkProjectPath, `${JSON.stringify({ framework: descriptor.id }, null, 2)}
-`);
-  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);
-    const descriptor = typeof manifest.framework === "string" ? getFrameworkDescriptorByIdFrom(manifest.framework, pluginDescriptors) : void 0;
-    return descriptor ?? resolveProjectFrameworkFromDependencies(projectRoot, pluginDescriptors);
-  } catch {
-    return resolveProjectFrameworkFromDependencies(projectRoot, pluginDescriptors);
-  }
-}
-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 {
-    const content = await readFile(frameworkProjectPath, "utf8");
-    const manifest = JSON.parse(content);
-    if (manifest.framework !== definition.framework) {
-      return;
-    }
-  } catch {
-    return;
-  }
-  const manager = await resolveProjectPackageManager(projectRoot);
-  const invocation = definition.commands[manager];
-  const command = invocation[0];
-  const args = invocation.slice(1);
-  await new Promise((resolve2, reject) => {
-    const child = spawn(command, args, {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve2(void 0);
-      } else {
-        reject(new Error(`${definition.errorLabel} exited with ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
-}
-function toPosixSlashes(value) {
-  return value.replaceAll("\\", "/");
-}
-var PACKAGE_MANIFEST_DISCOVERY_PATHS = /* @__PURE__ */ new Set([
-  "package.json",
-  "bun.lock",
-  "package-lock.json",
-  "pnpm-lock.yaml",
-  "yarn.lock"
-]);
-function resolveConfiguredBroadcastPath(project) {
-  const configuredPaths = project.config.paths;
-  return configuredPaths.broadcast ?? "server/broadcast";
-}
-function resolveConfiguredChannelsPath(project) {
-  const configuredPaths = project.config.paths;
-  return configuredPaths.channels ?? "server/channels";
-}
-function resolveConfiguredRealtimePath(project) {
-  const configuredPaths = project.config.paths;
-  return configuredPaths.realtime ?? "server/realtime";
-}
-function resolveConfiguredDiscoveryRoots(project) {
-  const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
-  const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
-  return [
-    project.config.paths.models,
-    project.config.paths.migrations,
-    project.config.paths.seeders,
-    project.config.paths.commands,
-    project.config.paths.jobs,
-    project.config.paths.events,
-    project.config.paths.listeners,
-    authorizationPoliciesPath,
-    authorizationAbilitiesPath,
-    resolveConfiguredBroadcastPath(project),
-    resolveConfiguredChannelsPath(project),
-    resolveConfiguredRealtimePath(project),
-    "config"
-  ];
-}
-function isDiscoveryRelevantPath(filePath, project) {
-  const normalized = toPosixSlashes(filePath);
-  if (PACKAGE_MANIFEST_DISCOVERY_PATHS.has(normalized)) {
-    return true;
-  }
-  const generatedSchemaPath = toPosixSlashes(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts");
-  if (normalized === generatedSchemaPath) {
-    return true;
-  }
-  if (normalized === ".holo-js/generated" || normalized.startsWith(".holo-js/generated/")) {
-    return false;
-  }
-  if (normalized === ".env" || normalized.startsWith(".env.")) {
-    return true;
-  }
-  return resolveConfiguredDiscoveryRoots(project).some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`));
-}
-function isRecursiveWatchUnsupported(error) {
-  return error instanceof Error && (error.message.includes("recursive") || "code" in error && error.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM");
-}
-function isIgnorableWatchError(error) {
-  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EPERM");
-}
-async function collectDirectoryTree(rootPath, directories) {
-  const rootStats = await stat(rootPath).catch(() => void 0);
-  if (!rootStats?.isDirectory()) {
-    return;
-  }
-  directories.add(rootPath);
-  const entries = await readdir(rootPath, { withFileTypes: true }).catch(() => []);
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    await collectDirectoryTree(join(rootPath, entry.name), directories);
-  }
-}
-async function collectDiscoveryWatchRoots(projectRoot, project) {
-  const directories = /* @__PURE__ */ new Set();
-  const roots = [
-    projectRoot,
-    ...resolveConfiguredDiscoveryRoots(project).map((root) => resolve(projectRoot, root)),
-    resolve(projectRoot, dirname(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts"))
-  ];
-  for (const rootPath of roots) {
-    await collectDirectoryTree(rootPath, directories);
-  }
-  return [...directories];
-}
-function normalizeWatchedFilePath(projectRoot, watchedRoot, fileName) {
-  return toPosixSlashes(relative(projectRoot, resolve(watchedRoot, fileName)));
-}
-async function runProjectDevServer(io, projectRoot, spawnProcess = spawn, createWatcher = watch, prepare = runProjectPrepare) {
-  let project = await ensureProjectConfig(projectRoot);
-  let refreshNonRecursiveWatchers;
-  let requestChildRestart;
-  const hotPrepare = prepare === runProjectPrepare ? runProjectHotPrepare : prepare;
-  const prepareDiscovery = async (syncFramework = false) => {
-    await (syncFramework ? prepare : hotPrepare)(projectRoot, io);
-    project = await ensureProjectConfig(projectRoot);
-    await refreshNonRecursiveWatchers?.();
-  };
-  await prepareDiscovery(true);
-  let pendingPrepare;
-  let queued = false;
-  let shuttingDown = false;
-  const rerunPrepare = () => {
-    if (shuttingDown) {
-      return;
-    }
-    if (pendingPrepare) {
-      queued = true;
-      return;
-    }
-    pendingPrepare = prepareDiscovery().then(() => {
-      requestChildRestart?.();
-    }).catch((error) => {
-      io.stderr.write(`${error instanceof Error ? error.message : String(error)}
-`);
-    }).finally(() => {
-      pendingPrepare = void 0;
-      if (queued) {
-        queued = false;
-        rerunPrepare();
-      }
-    });
-  };
-  const closeWatchers = (() => {
-    try {
-      const watcher = createWatcher(projectRoot, { recursive: true }, (_eventType, fileName) => {
-        if (shuttingDown || typeof fileName !== "string" || !isDiscoveryRelevantPath(fileName, project)) {
-          return;
-        }
-        rerunPrepare();
-      });
-      return () => watcher.close();
-    } catch (error) {
-      if (!isRecursiveWatchUnsupported(error)) {
-        throw error;
-      }
-      const watchers = [];
-      const closeAllWatchers = () => {
-        while (watchers.length > 0) {
-          watchers.pop()?.close();
-        }
-      };
-      refreshNonRecursiveWatchers = async () => {
-        closeAllWatchers();
-        const watchRoots = await collectDiscoveryWatchRoots(projectRoot, project);
-        for (const watchRoot of watchRoots) {
-          try {
-            watchers.push(createWatcher(watchRoot, { recursive: false }, (_eventType, fileName) => {
-              if (shuttingDown || typeof fileName !== "string") {
-                return;
-              }
-              const normalizedPath = normalizeWatchedFilePath(projectRoot, watchRoot, fileName);
-              if (!isDiscoveryRelevantPath(normalizedPath, project)) {
-                return;
-              }
-              rerunPrepare();
-            }));
-          } catch (watchError) {
-            if (!isIgnorableWatchError(watchError)) {
-              throw watchError;
-            }
-          }
-        }
-      };
-      return () => closeAllWatchers();
-    }
-  })();
-  await refreshNonRecursiveWatchers?.();
-  const invocation = resolveFrameworkRunnerInvocation(projectRoot, "dev");
-  while (!shuttingDown) {
-    const child = spawnProcess(invocation.command, [...invocation.args], {
-      cwd: projectRoot,
-      env: process.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    child.stdout?.on("data", (chunk) => io.stdout.write(chunk));
-    child.stderr?.on("data", (chunk) => io.stderr.write(chunk));
-    if (child.stdin) {
-      io.stdin.pipe(child.stdin);
-    }
-    const result = await new Promise((resolvePromise) => {
-      let restartRequested = false;
-      requestChildRestart = () => {
-        if (restartRequested || shuttingDown || typeof child.kill !== "function") {
-          return;
-        }
-        restartRequested = true;
-        child.kill("SIGTERM");
-      };
-      child.on("error", (error) => {
-        if (child.stdin) {
-          io.stdin.unpipe(child.stdin);
-        }
-        requestChildRestart = void 0;
-        if (restartRequested) {
-          resolvePromise({ kind: "restart" });
-          return;
-        }
-        resolvePromise({ kind: "error", error });
-      });
-      child.on("close", (code) => {
-        if (child.stdin) {
-          io.stdin.unpipe(child.stdin);
-        }
-        requestChildRestart = void 0;
-        if (restartRequested) {
-          resolvePromise({ kind: "restart" });
-          return;
-        }
-        resolvePromise({ kind: "close", code });
-      });
-    });
-    if (result.kind === "restart") {
-      continue;
-    }
-    shuttingDown = true;
-    closeWatchers();
-    await Promise.resolve(pendingPrepare);
-    if (result.kind === "error") {
-      throw result.error;
-    }
-    if (result.code === 0) {
-      return;
-    }
-    throw new Error(`Project development server failed with exit code ${result.code ?? "unknown"}.`);
-  }
-}
-
-export {
-  resolveProjectPackageManager,
-  resolvePackageManagerCommand,
-  resolvePackageManagerInstallInvocation,
-  runProjectBuild,
-  runProjectStartServer,
-  runProjectDependencyInstall,
-  runProjectPrepare,
-  toPosixSlashes,
-  isDiscoveryRelevantPath,
-  isRecursiveWatchUnsupported,
-  isIgnorableWatchError,
-  collectDirectoryTree,
-  collectDiscoveryWatchRoots,
-  normalizeWatchedFilePath,
-  runProjectDevServer
-};