@holo-js/cli 0.1.4 → 0.1.5

package/dist/{chunk-QYLSMF7V.mjs → chunk-OZUDZEAW.mjs}

@@ -1,29 +1,30 @@
-#!/usr/bin/env node
 import {
   fileExists
-} from "./chunk-M7J3YTHR.mjs";
+} from "./chunk-57SJ566R.mjs";
 import {
   prepareProjectDiscovery
-} from "./chunk-VT5IDQG6.mjs";
+} from "./chunk-UZTDQKIY.mjs";
 import {
   loadProjectConfig,
   resolveGeneratedSchemaPath
-} from "./chunk-ET7UXHHQ.mjs";
+} from "./chunk-5BLEC66P.mjs";
 import {
   loadGeneratedProjectRegistry
-} from "./chunk-3OTCSFDG.mjs";
+} from "./chunk-MXKNQACM.mjs";
 import {
   CLI_RUNTIME_ROOT,
   bundleProjectModule
-} from "./chunk-66FHW725.mjs";
+} from "./chunk-R6BWRY3E.mjs";
 
 // src/runtime.ts
-import { spawnSync } from "child_process";
-import { mkdir, rm, symlink } from "fs/promises";
+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");
@@ -196,6 +197,7 @@ import {
   createSchemaService,
   createMigrationService,
   createSeederService,
+  registerGeneratedTables,
   renderGeneratedSchemaModule,
   resetDB,
   resolveRuntimeConnectionManagerOptions,
@@ -275,6 +277,12 @@ async function writeGeneratedSchemaArtifact(manager, outputPath) {
   await writeFile(outputPath, source, 'utf8')
 }
 
+function syncGeneratedSchemaFromManager(manager) {
+  registerGeneratedTables(Object.fromEntries(
+    manager.connection().getSchemaRegistry().list().map(table => [table.tableName, table]),
+  ))
+}
+
 const manager = resolveRuntimeConnectionManagerOptions(payload.runtimeConfig)
 configureDB(manager)
 
@@ -297,7 +305,10 @@ try {
     if (executed.length === 0) {
       console.log('No migrations were executed.')
     } else {
-      console.log(\`Migrations executed: \${executed.map(item => item.name).join(', ')}\`)
+      console.log('Migrations executed:')
+      for (const item of executed) {
+        console.log(\`  \${item.name}\`)
+      }
     }
   } else if (payload.kind === 'fresh') {
     const migrations = []
@@ -315,10 +326,14 @@ try {
 
     const executed = await createMigrationService(manager.connection(), migrations).migrate({})
     await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath)
+    syncGeneratedSchemaFromManager(manager)
     if (executed.length === 0) {
       console.log('No migrations were executed.')
     } else {
-      console.log(\`Migrations executed: \${executed.map(item => item.name).join(', ')}\`)
+      console.log('Migrations executed:')
+      for (const item of executed) {
+        console.log(\`  \${item.name}\`)
+      }
     }
 
     if (payload.options?.seed) {
@@ -340,7 +355,10 @@ try {
       if (seeded.length === 0) {
         console.log('No seeders were executed.')
       } else {
-        console.log(\`Seeders executed: \${seeded.map(item => item.name).join(', ')}\`)
+        console.log('Seeders executed:')
+        for (const item of seeded) {
+          console.log(\`  \${item.name}\`)
+        }
       }
     }
   } else if (payload.kind === 'rollback') {
@@ -357,11 +375,18 @@ try {
     const rolledBack = await createMigrationService(manager.connection(), migrations).rollback(payload.options ?? {})
     await writeGeneratedSchemaArtifact(manager, payload.generatedSchemaOutputPath)
     if (rolledBack.length === 0) {
-      console.log('No migrations were executed.')
+      console.log('No migrations were rolled back.')
     } else {
-      console.log(\`Migrations executed: \${rolledBack.map(item => item.name).join(', ')}\`)
+      console.log('Migrations rolled back:')
+      for (const item of rolledBack) {
+        console.log(\`  \${item.name}\`)
+      }
     }
   } else if (payload.kind === 'seed') {
+    if (payload.generatedSchema) {
+      await preloadGeneratedSchema(manager, payload.generatedSchema)
+    }
+
     const seeders = []
     for (const entry of payload.seeders) {
       const seeder = resolveExport(await loadModule(entry), isSeeder)
@@ -375,7 +400,10 @@ try {
     if (executed.length === 0) {
       console.log('No seeders were executed.')
     } else {
-      console.log(\`Seeders executed: \${executed.map(item => item.name).join(', ')}\`)
+      console.log('Seeders executed:')
+      for (const item of executed) {
+        console.log(\`  \${item.name}\`)
+      }
     }
   } else if (payload.kind === 'prune') {
     const models = []
@@ -438,18 +466,65 @@ async function resolvePackageRootFromSpecifier(specifier) {
     current = parent;
   }
 }
-async function ensureRuntimeDependencyLink(projectRoot) {
+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 packageRoot = await resolvePackageRootFromSpecifier("@holo-js/db");
-  const namespaceDir = join(runtimeRoot, "node_modules", "@holo-js");
-  const targetPath = join(namespaceDir, "db");
-  await mkdir(namespaceDir, { recursive: true });
-  await rm(targetPath, { recursive: true, force: true });
-  await symlink(packageRoot, targetPath, "junction");
-  return runtimeRoot;
+  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 rm(join(projectRoot, CLI_RUNTIME_ROOT, "node_modules"), { recursive: true, force: true });
+  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 createRuntimeInvocation(script) {
   return {
@@ -457,6 +532,37 @@ function createRuntimeInvocation(script) {
     args: ["--input-type=module", "--eval", script]
   };
 }
+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) {
@@ -473,7 +579,12 @@ function getRuntimeFailureMessage(kind, result) {
   return `Runtime command "${kind}" failed.`;
 }
 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(
@@ -481,6 +592,7 @@ async function withRuntimeEnvironment(projectRoot, kind, options, callback) {
       envRuntimeConfig
     );
     const runtimeRoot = await ensureRuntimeDependencyLink(projectRoot);
+    dependencyLinkEnsured = true;
     const runtimePayload = JSON.stringify({
       kind,
       projectRoot,
@@ -495,20 +607,21 @@ async function withRuntimeEnvironment(projectRoot, kind, options, callback) {
       options
     });
     const runtime = createRuntimeInvocation(nodeRuntimeScript);
-    const result = spawnSync(runtime.command, runtime.args, {
+    const result = await runRuntimeInvocation(runtime.command, runtime.args, {
       cwd: runtimeRoot,
       env: {
         ...process.env,
         HOLO_RUNTIME_PAYLOAD: runtimePayload
-      },
-      encoding: "utf8"
+      }
     });
     if (result.status !== 0) {
       throw new Error(getRuntimeFailureMessage(kind, result));
     }
-    return await callback(result.stdout.trim());
+    return await callback((result.stdout ?? "").trim());
   } finally {
-    await cleanupRuntimeDependencyLink(projectRoot);
+    if (dependencyLinkEnsured) {
+      await cleanupRuntimeDependencyLink(projectRoot);
+    }
     await environment.cleanup();
   }
 }
@@ -534,6 +647,7 @@ export {
   ensureRuntimeDependencyLink,
   cleanupRuntimeDependencyLink,
   createRuntimeInvocation,
+  runRuntimeInvocation,
   getRuntimeFailureMessage,
   withRuntimeEnvironment
 };

package/dist/{chunk-66FHW725.mjs → chunk-R6BWRY3E.mjs}

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-
 // src/project/runtime.ts
 import { mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { existsSync } from "fs";
@@ -93,6 +91,14 @@ var MAIL_CONFIG_FILE_NAMES = [
   "config/mail.cts",
   "config/mail.cjs"
 ];
+var MEDIA_CONFIG_FILE_NAMES = [
+  "config/media.ts",
+  "config/media.mts",
+  "config/media.js",
+  "config/media.mjs",
+  "config/media.cts",
+  "config/media.cjs"
+];
 var SECURITY_CONFIG_FILE_NAMES = [
   "config/security.ts",
   "config/security.mts",
@@ -101,6 +107,14 @@ var SECURITY_CONFIG_FILE_NAMES = [
   "config/security.cts",
   "config/security.cjs"
 ];
+var CORS_CONFIG_FILE_NAMES = [
+  "config/cors.ts",
+  "config/cors.mts",
+  "config/cors.js",
+  "config/cors.mjs",
+  "config/cors.cts",
+  "config/cors.cjs"
+];
 var BROADCAST_CONFIG_FILE_NAMES = [
   "config/broadcast.ts",
   "config/broadcast.mts",
@@ -122,6 +136,7 @@ var GENERATED_ROOT = join(".holo-js", "generated");
 var GENERATED_INDEX_PATH = join(GENERATED_ROOT, "index.ts");
 var GENERATED_METADATA_PATH = join(GENERATED_ROOT, "metadata.ts");
 var GENERATED_MODELS_PATH = join(GENERATED_ROOT, "models.ts");
+var GENERATED_MODEL_TYPES_PATH = join(GENERATED_ROOT, "model-registry.d.ts");
 var GENERATED_MIGRATIONS_PATH = join(GENERATED_ROOT, "migrations.ts");
 var GENERATED_SEEDERS_PATH = join(GENERATED_ROOT, "seeders.ts");
 var GENERATED_COMMANDS_PATH = join(GENERATED_ROOT, "commands.ts");
@@ -134,13 +149,17 @@ var GENERATED_BROADCAST_MANIFEST_PATH = join(GENERATED_ROOT, "broadcast-manifest
 var GENERATED_AUTHORIZATION_ROOT = join(GENERATED_ROOT, "authorization");
 var GENERATED_AUTHORIZATION_REGISTRY_PATH = join(GENERATED_AUTHORIZATION_ROOT, "registry.ts");
 var GENERATED_AUTHORIZATION_TYPES_PATH = join(GENERATED_AUTHORIZATION_ROOT, "types.d.ts");
+var GENERATED_AUTH_TYPES_PATH = join(GENERATED_ROOT, "auth.d.ts");
 var GENERATED_CONFIG_TYPES_PATH = join(GENERATED_ROOT, "config.d.ts");
 var GENERATED_QUEUE_TYPES_PATH = join(GENERATED_ROOT, "queue.d.ts");
 var GENERATED_EVENT_TYPES_PATH = join(GENERATED_ROOT, "events.d.ts");
 var GENERATED_BROADCAST_TYPES_PATH = join(GENERATED_ROOT, "broadcast.d.ts");
 var GENERATED_REGISTRY_JSON_PATH = join(GENERATED_ROOT, "registry.json");
+var GENERATED_SCHEMA_RUNTIME_PATH = join(GENERATED_ROOT, "schema.mjs");
 var GENERATED_TSCONFIG_PATH = join(GENERATED_ROOT, "tsconfig.json");
 var GENERATED_GITIGNORE_PATH = join(GENERATED_ROOT, ".gitignore");
+var GENERATED_SVELTE_HOOKS_PATH = join(GENERATED_ROOT, "hooks.ts");
+var GENERATED_SVELTE_SERVER_HOOKS_PATH = join(GENERATED_ROOT, "hooks.server.ts");
 var CONFIG_EXTENSION_PRIORITY = [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"];
 var SUPPORTED_CONFIG_EXTENSIONS = new Set(CONFIG_EXTENSION_PRIORITY);
 var SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "security", "cache"];
@@ -406,7 +425,9 @@ export {
   CACHE_CONFIG_FILE_NAMES,
   NOTIFICATIONS_CONFIG_FILE_NAMES,
   MAIL_CONFIG_FILE_NAMES,
+  MEDIA_CONFIG_FILE_NAMES,
   SECURITY_CONFIG_FILE_NAMES,
+  CORS_CONFIG_FILE_NAMES,
   BROADCAST_CONFIG_FILE_NAMES,
   DB_DRIVER_PACKAGE_NAMES,
   COMMAND_FILE_PATTERN,
@@ -417,6 +438,7 @@ export {
   GENERATED_INDEX_PATH,
   GENERATED_METADATA_PATH,
   GENERATED_MODELS_PATH,
+  GENERATED_MODEL_TYPES_PATH,
   GENERATED_MIGRATIONS_PATH,
   GENERATED_SEEDERS_PATH,
   GENERATED_COMMANDS_PATH,
@@ -428,13 +450,17 @@ export {
   GENERATED_BROADCAST_MANIFEST_PATH,
   GENERATED_AUTHORIZATION_REGISTRY_PATH,
   GENERATED_AUTHORIZATION_TYPES_PATH,
+  GENERATED_AUTH_TYPES_PATH,
   GENERATED_CONFIG_TYPES_PATH,
   GENERATED_QUEUE_TYPES_PATH,
   GENERATED_EVENT_TYPES_PATH,
   GENERATED_BROADCAST_TYPES_PATH,
   GENERATED_REGISTRY_JSON_PATH,
+  GENERATED_SCHEMA_RUNTIME_PATH,
   GENERATED_TSCONFIG_PATH,
   GENERATED_GITIGNORE_PATH,
+  GENERATED_SVELTE_HOOKS_PATH,
+  GENERATED_SVELTE_SERVER_HOOKS_PATH,
   CONFIG_EXTENSION_PRIORITY,
   SUPPORTED_CONFIG_EXTENSIONS,
   toPosixPath,

package/dist/{chunk-ZLRO7HXY.mjs → chunk-SCCPDJGO.mjs}

@@ -1,21 +1,25 @@
 import {
   prepareProjectDiscovery
-} from "./chunk-S7P7EBM3.mjs";
+} from "./chunk-UZTDQKIY.mjs";
 import {
+  renderFrameworkRunner,
   syncManagedDriverDependencies
-} from "./chunk-MZXN2YMI.mjs";
+} from "./chunk-VCEO6N5T.mjs";
 import {
+  ensureGeneratedSchemaPlaceholder,
   ensureProjectConfig
-} from "./chunk-GSQ3HTRO.mjs";
+} from "./chunk-5BLEC66P.mjs";
 import {
-  readTextFile
-} from "./chunk-G5ADO27Q.mjs";
+  readTextFile,
+  writeTextFile
+} from "./chunk-R6BWRY3E.mjs";
 
 // src/dev.ts
 import { spawnSync, spawn } from "child_process";
 import { watch } from "fs";
 import { readdir, stat } from "fs/promises";
-import { dirname, join, relative, resolve } from "path";
+import { join, dirname, relative, resolve } from "path";
+import { readFile } from "fs/promises";
 async function fileExists(path) {
   try {
     await stat(path);
@@ -101,20 +105,158 @@ async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync)
 }
 async function runProjectPrepare(projectRoot, io) {
   const project = await ensureProjectConfig(projectRoot);
+  await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
   await prepareProjectDiscovery(projectRoot, project.config);
+  await refreshFrameworkRunner(projectRoot);
+  await runNuxtPrepare(projectRoot);
+  await runSvelteKitSync(projectRoot);
   const updatedDependencies = await syncManagedDriverDependencies(projectRoot);
   if (updatedDependencies && io) {
     await runProjectDependencyInstall(io, projectRoot);
     await prepareProjectDiscovery(projectRoot, project.config);
+    await refreshFrameworkRunner(projectRoot);
+    await runNuxtPrepare(projectRoot);
+    await runSvelteKitSync(projectRoot);
   }
 }
+async function refreshFrameworkRunner(projectRoot) {
+  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
+  const frameworkRunnerPath = resolve(projectRoot, ".holo-js/framework/run.mjs");
+  let framework;
+  try {
+    const content = await readFile(frameworkProjectPath, "utf8");
+    const manifest = JSON.parse(content);
+    if (manifest.framework !== "next" && manifest.framework !== "nuxt" && manifest.framework !== "sveltekit") {
+      return;
+    }
+    framework = manifest.framework;
+  } catch {
+    return;
+  }
+  await writeTextFile(frameworkRunnerPath, renderFrameworkRunner({ framework }));
+}
+async function runNuxtPrepare(projectRoot) {
+  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
+  try {
+    const content = await readFile(frameworkProjectPath, "utf8");
+    const manifest = JSON.parse(content);
+    if (manifest.framework !== "nuxt") {
+      return;
+    }
+  } catch {
+    return;
+  }
+  const manager = await resolveProjectPackageManager(projectRoot);
+  let command;
+  let args;
+  switch (manager) {
+    case "npm":
+      command = "npm";
+      args = ["exec", "--", "nuxt", "prepare"];
+      break;
+    case "pnpm":
+      command = "pnpm";
+      args = ["exec", "nuxt", "prepare"];
+      break;
+    case "yarn":
+      command = "yarn";
+      args = ["run", "nuxt", "prepare"];
+      break;
+    case "bun":
+    default:
+      command = "bun";
+      args = ["x", "nuxt", "prepare"];
+      break;
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  await new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2(void 0);
+      } else {
+        reject(new Error(`nuxt prepare exited with ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+async function runSvelteKitSync(projectRoot) {
+  const frameworkProjectPath = resolve(projectRoot, ".holo-js/framework/project.json");
+  try {
+    const content = await readFile(frameworkProjectPath, "utf8");
+    const manifest = JSON.parse(content);
+    if (manifest.framework !== "sveltekit") {
+      return;
+    }
+  } catch {
+    return;
+  }
+  const manager = await resolveProjectPackageManager(projectRoot);
+  let command;
+  let args;
+  switch (manager) {
+    case "npm":
+      command = "npm";
+      args = ["exec", "--", "svelte-kit", "sync"];
+      break;
+    case "pnpm":
+      command = "pnpm";
+      args = ["exec", "svelte-kit", "sync"];
+      break;
+    case "yarn":
+      command = "yarn";
+      args = ["run", "svelte-kit", "sync"];
+      break;
+    case "bun":
+    default:
+      command = "bun";
+      args = ["x", "svelte-kit", "sync"];
+      break;
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  await new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2(void 0);
+      } else {
+        reject(new Error(`svelte-kit sync exited with ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
 function toPosixSlashes(value) {
   return value.replaceAll("\\", "/");
 }
+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 isDiscoveryRelevantPath(filePath, project) {
   const normalized = toPosixSlashes(filePath);
+  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;
+  }
   const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
   const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
+  const broadcastPath = resolveConfiguredBroadcastPath(project);
+  const channelsPath = resolveConfiguredChannelsPath(project);
   const roots = [
     project.config.paths.models,
     project.config.paths.migrations,
@@ -125,11 +267,9 @@ function isDiscoveryRelevantPath(filePath, project) {
     project.config.paths.listeners,
     authorizationPoliciesPath,
     authorizationAbilitiesPath,
-    "server/broadcast",
-    "server/channels",
-    project.config.paths.generatedSchema,
-    "config",
-    ".holo-js/generated"
+    broadcastPath,
+    channelsPath,
+    "config"
   ];
   if (normalized === ".env" || normalized.startsWith(".env.")) {
     return true;
@@ -160,10 +300,11 @@ async function collectDiscoveryWatchRoots(projectRoot, project) {
   const directories = /* @__PURE__ */ new Set();
   const authorizationPoliciesPath = project.config.paths.authorizationPolicies || "server/policies";
   const authorizationAbilitiesPath = project.config.paths.authorizationAbilities || "server/abilities";
+  const broadcastPath = resolveConfiguredBroadcastPath(project);
+  const channelsPath = resolveConfiguredChannelsPath(project);
   const roots = [
     projectRoot,
     resolve(projectRoot, "config"),
-    resolve(projectRoot, ".holo-js/generated"),
     resolve(projectRoot, project.config.paths.models),
     resolve(projectRoot, project.config.paths.migrations),
     resolve(projectRoot, project.config.paths.seeders),
@@ -173,9 +314,9 @@ async function collectDiscoveryWatchRoots(projectRoot, project) {
     resolve(projectRoot, project.config.paths.listeners),
     resolve(projectRoot, authorizationPoliciesPath),
     resolve(projectRoot, authorizationAbilitiesPath),
-    resolve(projectRoot, "server/broadcast"),
-    resolve(projectRoot, "server/channels"),
-    dirname(resolve(projectRoot, project.config.paths.generatedSchema))
+    resolve(projectRoot, broadcastPath),
+    resolve(projectRoot, channelsPath),
+    resolve(projectRoot, dirname(project.config.paths.generatedSchema ?? ".holo-js/generated/schema.generated.ts"))
   ];
   for (const rootPath of roots) {
     await collectDirectoryTree(rootPath, directories);