@holo-js/cli 0.1.8 → 0.2.0

package/dist/{chunk-D4NXGVV4.mjs → chunk-2RGJTPYF.mjs}

@@ -1,7 +1,7 @@
 import {
   loadGeneratedProjectRegistry,
   writeGeneratedProjectRegistry
-} from "./chunk-O6AXHL7Z.mjs";
+} from "./chunk-2DKQKZML.mjs";
 import {
   COMMAND_FILE_PATTERN,
   MIGRATION_NAME_PATTERN,
@@ -17,7 +17,7 @@ import {
   pathExists,
   readTextFile,
   toPosixPath
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/project/discovery.ts
 import { resolve as resolve2 } from "path";
@@ -55,37 +55,25 @@ function deriveJobNameFromPath(jobsRoot, sourcePath) {
   const relativePath = toPosixPath(relative(jobsRoot, sourcePath));
   return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(".");
 }
-function deriveEventNameFromPath(eventsRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(eventsRoot, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+function deriveDottedNameFromPath(root, sourcePath, emptyMessage) {
+  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
   const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
   if (!derived) {
-    throw new Error("[Holo Events] Derived event names require a non-empty source path.");
+    throw new Error(emptyMessage);
   }
   return derived;
 }
+function deriveEventNameFromPath(eventsRoot, sourcePath) {
+  return deriveDottedNameFromPath(eventsRoot, sourcePath, "[Holo Events] Derived event names require a non-empty source path.");
+}
 function deriveListenerIdFromPath(listenersRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(listenersRoot, sourcePath));
-  const derived = relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Events] Derived listener identifiers require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(listenersRoot, sourcePath, "[Holo Events] Derived listener identifiers require a non-empty source path.");
 }
 function deriveBroadcastNameFromPath(root, sourcePath) {
-  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
-  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Broadcast] Derived broadcast names require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived broadcast names require a non-empty source path.");
 }
 function deriveChannelPatternFromPath(root, sourcePath) {
-  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
-  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error("[Holo Broadcast] Derived channel patterns require a non-empty source path.");
-  }
-  return derived;
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived channel patterns require a non-empty source path.");
 }
 function resolveDiscoveredJobMetadata(job, sourcePath, derivedName, queueConfig) {
   const connection = job.connection ?? queueConfig.default;
@@ -356,6 +344,28 @@ function validateMigrationName(name, message) {
 }
 
 // src/project/discovery.ts
+function resolveBroadcastExportEntry(moduleValue, discovery) {
+  if (!moduleValue || typeof moduleValue !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(moduleValue);
+  const orderedEntries = "default" in moduleValue ? [
+    ["default", moduleValue.default],
+    ...entries.filter(([exportName]) => exportName !== "default")
+  ] : entries;
+  for (const [exportName, value] of orderedEntries) {
+    if (discovery.isBroadcastDefinition(value)) {
+      return { exportName, value };
+    }
+    if (typeof value === "function") {
+      const resolved = value(...Array.from({ length: value.length }, () => "__holo_discovery__"));
+      if (discovery.isBroadcastDefinition(resolved)) {
+        return { exportName, value: resolved };
+      }
+    }
+  }
+  return void 0;
+}
 async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjectConfig()) {
   const loadedConfig = await loadConfigDirectory(projectRoot, {
     processEnv: process.env
@@ -565,9 +575,9 @@ async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjec
   const broadcast = [];
   for (const filePath of broadcastFiles) {
     const relativePath = makeProjectRelativePath(projectRoot, filePath);
-    const exportedBroadcast = resolveNamedExportEntry(
+    const exportedBroadcast = resolveBroadcastExportEntry(
       await importProjectModule(projectRoot, filePath),
-      (value) => broadcastDiscovery.isBroadcastDefinition(value)
+      broadcastDiscovery
     );
     if (!exportedBroadcast) {
       throw new Error(`Discovered broadcast "${relativePath}" does not export a Holo broadcast definition.`);
@@ -601,6 +611,7 @@ async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjec
       sourcePath: relativePath,
       pattern,
       exportName: exportedChannel.exportName,
+      ...typeof normalizedChannel.guard === "string" ? { guard: normalizedChannel.guard } : {},
       type: normalizedChannel.type,
       params: broadcastDiscovery.broadcastInternals.extractChannelPatternParamNames(pattern),
       whispers: Object.freeze(Object.keys(normalizedChannel.whispers))

package/dist/{chunk-2NUEWM2P.mjs → chunk-EWYXSN2C.mjs}

@@ -1,20 +1,20 @@
 import {
   prepareProjectDiscovery
-} from "./chunk-D4NXGVV4.mjs";
+} from "./chunk-2RGJTPYF.mjs";
 import {
   syncManagedDriverDependencies
-} from "./chunk-SABHUOON.mjs";
+} from "./chunk-UPZH6KCF.mjs";
 import {
   ensureGeneratedSchemaPlaceholder,
   ensureProjectConfig
-} from "./chunk-DFKX4YT4.mjs";
+} from "./chunk-ONKESAQA.mjs";
 import {
   renderFrameworkRunner
-} from "./chunk-O6AXHL7Z.mjs";
+} from "./chunk-2DKQKZML.mjs";
 import {
   readTextFile,
   writeTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/dev.ts
 import { spawnSync, spawn } from "child_process";
@@ -105,22 +105,52 @@ async function runProjectDependencyInstall(io, projectRoot, spawn2 = spawnSync)
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || "Project dependency installation failed.");
   }
 }
-async function runProjectPrepare(projectRoot, io) {
+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);
-  await runNuxtPrepare(projectRoot);
-  await runSvelteKitSync(projectRoot);
+  const syncFramework = options.syncFramework ?? true;
+  if (syncFramework) {
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+    await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+  }
   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);
+    if (syncFramework) {
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[0]);
+      await runFrameworkSync(projectRoot, FRAMEWORK_SYNC_DEFINITIONS[1]);
+    }
   }
 }
+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");
@@ -137,42 +167,23 @@ async function refreshFrameworkRunner(projectRoot) {
   }
   await writeTextFile(frameworkRunnerPath, renderFrameworkRunner({ framework }));
 }
-async function runNuxtPrepare(projectRoot) {
+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 !== "nuxt") {
+    if (manifest.framework !== definition.framework) {
       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");
+  const invocation = definition.commands[manager];
+  const command = invocation[0];
+  const args = invocation.slice(1);
   await new Promise((resolve2, reject) => {
-    const child = spawn2(command, args, {
+    const child = spawn(command, args, {
       cwd: projectRoot,
       stdio: "inherit"
     });
@@ -180,56 +191,7 @@ async function runNuxtPrepare(projectRoot) {
       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}`));
+        reject(new Error(`${definition.errorLabel} exited with ${code}`));
       }
     });
     child.on("error", reject);
@@ -238,6 +200,13 @@ async function runSvelteKitSync(projectRoot) {
 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";
@@ -246,20 +215,14 @@ 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;
-  }
+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";
-  const broadcastPath = resolveConfiguredBroadcastPath(project);
-  const channelsPath = resolveConfiguredChannelsPath(project);
-  const roots = [
+  return [
     project.config.paths.models,
     project.config.paths.migrations,
     project.config.paths.seeders,
@@ -269,14 +232,28 @@ function isDiscoveryRelevantPath(filePath, project) {
     project.config.paths.listeners,
     authorizationPoliciesPath,
     authorizationAbilitiesPath,
-    broadcastPath,
-    channelsPath,
+    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 roots.some((root) => normalized === root || normalized.startsWith(`${toPosixSlashes(root)}/`));
+  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");
@@ -300,24 +277,9 @@ async function collectDirectoryTree(rootPath, directories) {
 }
 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, project.config.paths.models),
-    resolve(projectRoot, project.config.paths.migrations),
-    resolve(projectRoot, project.config.paths.seeders),
-    resolve(projectRoot, project.config.paths.commands),
-    resolve(projectRoot, project.config.paths.jobs),
-    resolve(projectRoot, project.config.paths.events),
-    resolve(projectRoot, project.config.paths.listeners),
-    resolve(projectRoot, authorizationPoliciesPath),
-    resolve(projectRoot, authorizationAbilitiesPath),
-    resolve(projectRoot, broadcastPath),
-    resolve(projectRoot, channelsPath),
+    ...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) {
@@ -332,12 +294,13 @@ async function runProjectDevServer(io, projectRoot, spawnProcess = spawn, create
   let project = await ensureProjectConfig(projectRoot);
   let refreshNonRecursiveWatchers;
   let requestChildRestart;
-  const prepareDiscovery = async () => {
-    await prepare(projectRoot, io);
+  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();
+  await prepareDiscovery(true);
   let pendingPrepare;
   let queued = false;
   let shuttingDown = false;

package/dist/{chunk-F4MT6GBK.mjs → chunk-FGQ2I2YH.mjs}

@@ -1,6 +1,6 @@
 import {
   readTextFile
-} from "./chunk-R6BWRY3E.mjs";
+} from "./chunk-ILU426CF.mjs";
 
 // src/package-json.ts
 import { join } from "path";

package/dist/chunk-I7QBCEV7.mjs

@@ -0,0 +1,33 @@
+// src/io.ts
+import { spinner } from "@clack/prompts";
+function writeLine(stream, message = "") {
+  stream.write(`${message}
+`);
+}
+async function runWithSpinner(io, message, task, successMessage = message) {
+  if (!supportsSpinner(io)) {
+    return task();
+  }
+  const loading = spinner({
+    input: io.stdin,
+    output: io.stdout
+  });
+  loading.start(message);
+  try {
+    const result = await task();
+    loading.stop(successMessage);
+    return result;
+  } catch (error) {
+    loading.error("Command failed.");
+    throw error;
+  }
+}
+function supportsSpinner(io) {
+  return io.stdin.isTTY === true && io.stdout.isTTY === true && typeof io.stdin.setRawMode === "function";
+}
+
+export {
+  writeLine,
+  runWithSpinner,
+  supportsSpinner
+};

package/dist/{chunk-R6BWRY3E.mjs → chunk-ILU426CF.mjs}

@@ -145,6 +145,7 @@ var GENERATED_EVENTS_PATH = join(GENERATED_ROOT, "events.ts");
 var GENERATED_LISTENERS_PATH = join(GENERATED_ROOT, "listeners.ts");
 var GENERATED_BROADCAST_PATH = join(GENERATED_ROOT, "broadcast.ts");
 var GENERATED_CHANNELS_PATH = join(GENERATED_ROOT, "channels.ts");
+var GENERATED_CHANNEL_IMPORTER_PATH = join(GENERATED_ROOT, "channel-importer.ts");
 var GENERATED_BROADCAST_MANIFEST_PATH = join(GENERATED_ROOT, "broadcast-manifest.ts");
 var GENERATED_AUTHORIZATION_ROOT = join(GENERATED_ROOT, "authorization");
 var GENERATED_AUTHORIZATION_REGISTRY_PATH = join(GENERATED_AUTHORIZATION_ROOT, "registry.ts");
@@ -162,7 +163,7 @@ 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"];
+var SUPPORTED_SCAFFOLD_OPTIONAL_PACKAGES = ["storage", "events", "queue", "validation", "forms", "auth", "authorization", "notifications", "mail", "broadcast", "realtime", "security", "cache"];
 var SUPPORTED_QUEUE_INSTALLER_DRIVERS = ["sync", "redis", "database"];
 var SUPPORTED_CACHE_INSTALLER_DRIVERS = ["file", "redis", "database"];
 var HOLO_EVENT_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.events.definition");
@@ -447,6 +448,7 @@ export {
   GENERATED_LISTENERS_PATH,
   GENERATED_BROADCAST_PATH,
   GENERATED_CHANNELS_PATH,
+  GENERATED_CHANNEL_IMPORTER_PATH,
   GENERATED_BROADCAST_MANIFEST_PATH,
   GENERATED_AUTHORIZATION_REGISTRY_PATH,
   GENERATED_AUTHORIZATION_TYPES_PATH,