@holo-js/cli 0.1.9 → 0.2.1

package/dist/bin/holo.mjs

@@ -4,35 +4,38 @@ import {
   SUPPORTED_INSTALL_TARGETS,
   SUPPORTED_QUEUE_INSTALL_DRIVERS,
   collectMultiStringFlag,
-  confirm,
   ensureRequiredArg,
   isInteractive,
   normalizeChoice,
   normalizeOptionalPackages,
   parseNumberFlag,
   parseTokens,
+  promptChoice,
+  promptMultiChoice,
   resolveBooleanFlag,
   resolveNewProjectInput,
   resolveStringFlag,
   splitCsv
-} from "../chunk-5EU32E7X.mjs";
+} from "../chunk-VRGB6DIS.mjs";
 import {
   hasProjectDependency
-} from "../chunk-F4MT6GBK.mjs";
+} from "../chunk-FGQ2I2YH.mjs";
 import {
+  runWithSpinner,
+  supportsSpinner,
   writeLine
-} from "../chunk-ZXDU7RHU.mjs";
+} from "../chunk-I7QBCEV7.mjs";
 import {
   fileExists
-} from "../chunk-57SJ566R.mjs";
+} from "../chunk-LBJAJLKU.mjs";
 import "../chunk-D7O4SU6N.mjs";
-import "../chunk-7JR73TOH.mjs";
-import "../chunk-WRZFATUT.mjs";
-import "../chunk-SRPGIWCF.mjs";
-import "../chunk-IMOGEKB4.mjs";
+import "../chunk-VP2E62DF.mjs";
+import "../chunk-4OHJC3GL.mjs";
+import "../chunk-YEFJBN56.mjs";
+import "../chunk-J76GH2DR.mjs";
 import {
   SUPPORTED_AUTH_SOCIAL_PROVIDERS
-} from "../chunk-R6BWRY3E.mjs";
+} from "../chunk-ILU426CF.mjs";
 
 // src/cli.ts
 import { resolve as resolve2 } from "path";
@@ -105,6 +108,10 @@ async function generateProjectAppKey(projectRoot) {
 }
 
 // src/cli.ts
+var AUTH_INSTALL_FEATURES = ["social", "workos", "clerk"];
+var AUTH_SOCIAL_PROVIDER_MODES = ["default", "specific"];
+var EVENTS_QUEUE_ACTIONS = ["skip", "enable"];
+var MODEL_GENERATOR_OPTIONS = ["migration", "observer", "seeder", "factory"];
 var runtimeModulePromise;
 var queueModulePromise;
 var cacheModulePromise;
@@ -120,59 +127,59 @@ var projectDiscoveryModulePromise;
 var projectRuntimeModulePromise;
 var projectScaffoldModulePromise;
 function loadRuntimeModule() {
-  runtimeModulePromise ??= import("../runtime-BI343WHS.mjs");
+  runtimeModulePromise ??= import("../runtime-HGK2MWSC.mjs");
   return runtimeModulePromise;
 }
 function loadQueueModule() {
-  queueModulePromise ??= import("../queue-BY3PLH4I.mjs");
+  queueModulePromise ??= import("../queue-GY7BWGTX.mjs");
   return queueModulePromise;
 }
 function loadCacheModule() {
-  cacheModulePromise ??= import("../cache-ETOIQ5IG.mjs");
+  cacheModulePromise ??= import("../cache-634WUR3T.mjs");
   return cacheModulePromise;
 }
 function loadQueueMigrationsModule() {
-  queueMigrationsModulePromise ??= import("../queue-migrations-YZUKEZK7.mjs");
+  queueMigrationsModulePromise ??= import("../queue-migrations-J7YPIKRB.mjs");
   return queueMigrationsModulePromise;
 }
 function loadCacheMigrationsModule() {
-  cacheMigrationsModulePromise ??= import("../cache-migrations-2GGI4TJK.mjs");
+  cacheMigrationsModulePromise ??= import("../cache-migrations-2NBEUF2T.mjs");
   return cacheMigrationsModulePromise;
 }
 function loadMediaMigrationsModule() {
-  mediaMigrationsModulePromise ??= import("../media-migrations-JQSDCC7S.mjs");
+  mediaMigrationsModulePromise ??= import("../media-migrations-5EISZBSD.mjs");
   return mediaMigrationsModulePromise;
 }
 function loadGeneratorsModule() {
-  generatorsModulePromise ??= import("../generators-UI2LJK3O.mjs");
+  generatorsModulePromise ??= import("../generators-DEPLONDJ.mjs");
   return generatorsModulePromise;
 }
 function loadBroadcastModule() {
-  broadcastModulePromise ??= import("../broadcast-VR46UZEL.mjs");
+  broadcastModulePromise ??= import("../broadcast-ZIFYFOUQ.mjs");
   return broadcastModulePromise;
 }
 function loadSecurityModule() {
-  securityModulePromise ??= import("../security-TYPVOYGF.mjs");
+  securityModulePromise ??= import("../security-XVG673UR.mjs");
   return securityModulePromise;
 }
 function loadDevModule() {
-  devModulePromise ??= import("../dev-6RG5SSZ7.mjs");
+  devModulePromise ??= import("../dev-M2GGURAX.mjs");
   return devModulePromise;
 }
 function loadProjectConfigModule() {
-  projectConfigModulePromise ??= import("../config-ARLE6PKR.mjs");
+  projectConfigModulePromise ??= import("../config-MD27U4FM.mjs");
   return projectConfigModulePromise;
 }
 function loadProjectDiscoveryModule() {
-  projectDiscoveryModulePromise ??= import("../discovery-FCVGQQVD.mjs");
+  projectDiscoveryModulePromise ??= import("../discovery-GWTBF5RZ.mjs");
   return projectDiscoveryModulePromise;
 }
 function loadProjectRuntimeModule() {
-  projectRuntimeModulePromise ??= import("../runtime-ZKD6URAV.mjs");
+  projectRuntimeModulePromise ??= import("../runtime-GSXF4NB3.mjs");
   return projectRuntimeModulePromise;
 }
 function loadProjectScaffoldModule() {
-  projectScaffoldModulePromise ??= import("../scaffold-UBOS2NZR.mjs");
+  projectScaffoldModulePromise ??= import("../scaffold-Y232IGYS.mjs");
   return projectScaffoldModulePromise;
 }
 async function resolveRuntimeExecutor(runtimeExecutor) {
@@ -182,14 +189,18 @@ var projectExecutorLoaders = {
   runProjectPrepare: async () => (await loadDevModule()).runProjectPrepare,
   runProjectDevServer: async () => (await loadDevModule()).runProjectDevServer,
   runProjectLifecycleScript: async () => (await loadDevModule()).runProjectLifecycleScript,
+  runProjectStartServer: async () => (await loadDevModule()).runProjectStartServer,
   runProjectDependencyInstall: async () => (await loadDevModule()).runProjectDependencyInstall
 };
-async function resolveProjectExecutor(projectExecutors, key) {
-  const existing = projectExecutors[key];
+async function resolveExecutor(executors, loaders, key) {
+  const existing = executors[key];
   if (existing) {
     return existing;
   }
-  return projectExecutorLoaders[key]();
+  return await loaders[key]();
+}
+async function resolveProjectExecutor(projectExecutors, key) {
+  return await resolveExecutor(projectExecutors, projectExecutorLoaders, key);
 }
 var queueExecutorLoaders = {
   runQueueFailedTableCommand: async () => (await loadQueueMigrationsModule()).runQueueFailedTableCommand,
@@ -215,32 +226,16 @@ var broadcastExecutorLoaders = {
   runBroadcastWorkCommand: async () => (await loadBroadcastModule()).runBroadcastWorkCommand
 };
 async function resolveQueueExecutor(queueExecutors, key) {
-  const existing = queueExecutors[key];
-  if (existing) {
-    return existing;
-  }
-  return queueExecutorLoaders[key]();
+  return await resolveExecutor(queueExecutors, queueExecutorLoaders, key);
 }
 async function resolveCacheExecutor(cacheExecutors, key) {
-  const existing = cacheExecutors[key];
-  if (existing) {
-    return existing;
-  }
-  return cacheExecutorLoaders[key]();
+  return await resolveExecutor(cacheExecutors, cacheExecutorLoaders, key);
 }
 async function resolveMediaExecutor(mediaExecutors, key) {
-  const existing = mediaExecutors[key];
-  if (existing) {
-    return existing;
-  }
-  return mediaExecutorLoaders[key]();
+  return await resolveExecutor(mediaExecutors, mediaExecutorLoaders, key);
 }
 async function resolveBroadcastExecutor(broadcastExecutors, key) {
-  const existing = broadcastExecutors[key];
-  if (existing) {
-    return existing;
-  }
-  return broadcastExecutorLoaders[key]();
+  return await resolveExecutor(broadcastExecutors, broadcastExecutorLoaders, key);
 }
 async function resolveGeneratorCommand(key) {
   return (await loadGeneratorsModule())[key];
@@ -295,10 +290,12 @@ async function runProjectDependencyInstallAfterPackageJsonUpdate(context, projec
   const runProjectPrepare = await resolveProjectExecutor(projectExecutors, "runProjectPrepare");
   await runProjectPrepare(context.projectRoot, context);
 }
-async function runProjectDependencyInstallForProject(context, projectExecutors, projectRoot) {
+async function runProjectDependencyInstallForProject(context, projectExecutors, projectRoot, options = {}) {
   const runProjectDependencyInstall = await resolveProjectExecutor(projectExecutors, "runProjectDependencyInstall");
   await runProjectDependencyInstall(context, projectRoot);
-  writeLine(context.stdout, "  - installed dependencies");
+  if (options.writeStatus ?? true) {
+    writeLine(context.stdout, "  - installed dependencies");
+  }
 }
 function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, projectExecutors = {}, broadcastExecutors = {}, securityExecutors = {}, cacheExecutors = {}, mediaExecutors = {}) {
   return [
@@ -317,7 +314,7 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
     {
       name: "new",
       description: "Scaffold a new Holo project",
-      usage: "holo new <name> [--framework <nuxt|next|sveltekit>] [--database <sqlite|mysql|postgres>] [--package-manager <bun|npm|pnpm|yarn>] [--package <storage|events|queue|validation|forms|auth|authorization|notifications|mail|broadcast|security|cache>] [--storage-default-disk <local|public>]",
+      usage: "holo new <name> [--framework <nuxt|next|sveltekit>] [--database <sqlite|mysql|postgres>] [--package-manager <bun|npm|pnpm|yarn>] [--package <storage|events|queue|validation|forms|auth|authorization|notifications|mail|broadcast|realtime|security|cache>] [--storage-default-disk <local|public>]",
       source: "internal",
       async prepare(input) {
         const resolved = await resolveNewProjectInput(context, input);
@@ -343,16 +340,28 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
         );
         const targetDir = resolve2(commandContext.cwd, projectName);
         const { scaffoldProject } = await loadProjectScaffoldModule();
-        await scaffoldProject(targetDir, {
-          projectName,
-          framework,
-          databaseDriver,
-          packageManager,
-          storageDefaultDisk,
-          optionalPackages
-        });
+        await runWithSpinner(
+          context,
+          "Creating project files...",
+          () => scaffoldProject(targetDir, {
+            projectName,
+            framework,
+            databaseDriver,
+            packageManager,
+            storageDefaultDisk,
+            optionalPackages
+          }),
+          "Project files created."
+        );
         writeLine(context.stdout, `Created Holo project: ${targetDir}`);
-        await runProjectDependencyInstallForProject(context, projectExecutors, targetDir);
+        await runWithSpinner(
+          context,
+          "Installing dependencies...",
+          () => runProjectDependencyInstallForProject(context, projectExecutors, targetDir, {
+            writeStatus: !supportsSpinner(context)
+          }),
+          "Dependencies installed."
+        );
         writeLine(context.stdout);
         writeLine(context.stdout, "Next steps");
         writeLine(context.stdout, `  cd ${projectName}`);
@@ -378,11 +387,13 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
     {
       name: "install",
       description: "Install first-party Holo support into an existing project.",
-      usage: "holo install <queue|events|auth|authorization|notifications|mail|broadcast|security|cache|media> [--driver <queue: sync|file|redis|database; cache: file|redis|database>] [--social] [--provider <google|github|discord|facebook|apple|linkedin>] [--workos] [--clerk]",
+      usage: "holo install <queue|events|auth|authorization|notifications|mail|broadcast|realtime|security|cache|media> [--driver <queue: sync|file|redis|database; cache: file|redis|database>] [--social] [--provider <google|github|discord|facebook|apple|linkedin>] [--workos] [--clerk]",
       source: "internal",
       async prepare(input) {
+        const interactive = isInteractive(context, input.flags);
+        const requestedTarget = input.args[0]?.trim();
         const target = normalizeChoice(
-          await ensureRequiredArg(context, input, 0, "Install target"),
+          requestedTarget || (interactive ? await promptChoice(context, "Install target", SUPPORTED_INSTALL_TARGETS, "queue") : await ensureRequiredArg(context, input, 0, "Install target")),
           SUPPORTED_INSTALL_TARGETS,
           "install target"
         );
@@ -405,17 +416,65 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
         if (target === "broadcast" && requestedDriver) {
           throw new Error("The broadcast installer does not support --driver.");
         }
+        if (target === "realtime" && requestedDriver) {
+          throw new Error("The realtime installer does not support --driver.");
+        }
         if (target === "security" && requestedDriver) {
           throw new Error("The security installer does not support --driver.");
         }
         if (target === "media" && requestedDriver) {
           throw new Error("The media installer does not support --driver.");
         }
-        const driver = target === "queue" ? requestedDriver ? normalizeChoice(requestedDriver, SUPPORTED_QUEUE_INSTALL_DRIVERS, "queue driver") : "sync" : target === "cache" ? requestedDriver ? normalizeChoice(requestedDriver, SUPPORTED_CACHE_INSTALL_DRIVERS, "cache driver") : "file" : void 0;
-        const socialProviders = target === "auth" ? (collectMultiStringFlag(input.flags, "provider") ?? []).flatMap((entry) => splitCsv(entry) ?? []).map((provider) => normalizeChoice(provider, SUPPORTED_AUTH_SOCIAL_PROVIDERS, "auth social provider")) : [];
-        const social = target === "auth" ? resolveBooleanFlag(input.flags, "social") === true || socialProviders.length > 0 : false;
-        const workos = target === "auth" ? resolveBooleanFlag(input.flags, "workos") === true : false;
-        const clerk = target === "auth" ? resolveBooleanFlag(input.flags, "clerk") === true : false;
+        const driver = target === "queue" ? requestedDriver ? normalizeChoice(requestedDriver, SUPPORTED_QUEUE_INSTALL_DRIVERS, "queue driver") : interactive ? await promptChoice(context, "Queue driver", SUPPORTED_QUEUE_INSTALL_DRIVERS, "sync") : "sync" : target === "cache" ? requestedDriver ? normalizeChoice(requestedDriver, SUPPORTED_CACHE_INSTALL_DRIVERS, "cache driver") : interactive ? await promptChoice(context, "Cache driver", SUPPORTED_CACHE_INSTALL_DRIVERS, "file") : "file" : void 0;
+        let socialProviders = target === "auth" ? (collectMultiStringFlag(input.flags, "provider") ?? []).flatMap((entry) => splitCsv(entry) ?? []).map((provider) => normalizeChoice(provider, SUPPORTED_AUTH_SOCIAL_PROVIDERS, "auth social provider")) : [];
+        let social = target === "auth" ? resolveBooleanFlag(input.flags, "social") === true || socialProviders.length > 0 : false;
+        let workos = target === "auth" ? resolveBooleanFlag(input.flags, "workos") === true : false;
+        let clerk = target === "auth" ? resolveBooleanFlag(input.flags, "clerk") === true : false;
+        const authFlagsProvided = "social" in input.flags || "provider" in input.flags || "workos" in input.flags || "clerk" in input.flags;
+        if (target === "auth" && interactive && !authFlagsProvided) {
+          const features = await promptMultiChoice(
+            context,
+            "Auth providers",
+            AUTH_INSTALL_FEATURES,
+            {
+              labels: {
+                social: "Social OAuth",
+                workos: "WorkOS",
+                clerk: "Clerk"
+              },
+              hints: {
+                social: "Google, GitHub, Discord, Facebook, Apple, or LinkedIn"
+              }
+            }
+          );
+          social = features.includes("social");
+          workos = features.includes("workos");
+          clerk = features.includes("clerk");
+          if (social) {
+            const providerMode = await promptChoice(
+              context,
+              "Social provider setup",
+              AUTH_SOCIAL_PROVIDER_MODES,
+              "default",
+              {
+                labels: {
+                  default: "Default social setup",
+                  specific: "Choose specific providers"
+                }
+              }
+            );
+            if (providerMode === "specific") {
+              socialProviders = [
+                ...await promptMultiChoice(
+                  context,
+                  "Social providers",
+                  SUPPORTED_AUTH_SOCIAL_PROVIDERS,
+                  { required: true }
+                )
+              ];
+            }
+          }
+        }
         return {
           args: [target],
           flags: {
@@ -439,12 +498,19 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
           const eventsResult = await installEventsIntoProject(context.projectRoot);
           let queueResult;
           if (!queueConfigured && isInteractive(context, commandContext.flags)) {
-            const enableQueuedListeners = await confirm(
+            const queueAction = await promptChoice(
               context,
-              "Enable queued listeners too?",
-              false
+              "Queued listeners",
+              EVENTS_QUEUE_ACTIONS,
+              "skip",
+              {
+                labels: {
+                  skip: "Skip queued listeners",
+                  enable: "Enable queued listeners"
+                }
+              }
             );
-            if (enableQueuedListeners) {
+            if (queueAction === "enable") {
               queueResult = await installQueueIntoProject2(context.projectRoot, { driver: "sync" });
             }
           }
@@ -545,6 +611,17 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
           await runProjectDependencyInstallAfterPackageJsonUpdate(context, projectExecutors, result2.updatedPackageJson);
           return;
         }
+        if (target === "realtime") {
+          const { installRealtimeIntoProject } = await loadProjectScaffoldModule();
+          const result2 = await installRealtimeIntoProject(context.projectRoot);
+          const changed2 = result2.updatedPackageJson || result2.createdRealtimeDirectory || result2.createdFrameworkSetup;
+          writeLine(context.stdout, changed2 ? "Installed realtime support." : "Realtime support is already installed.");
+          if (result2.updatedPackageJson) writeLine(context.stdout, "  - updated package.json");
+          if (result2.createdRealtimeDirectory) writeLine(context.stdout, "  - created server/realtime");
+          if (result2.createdFrameworkSetup) writeLine(context.stdout, "  - created realtime framework setup");
+          await runProjectDependencyInstallAfterPackageJsonUpdate(context, projectExecutors, result2.updatedPackageJson);
+          return;
+        }
         if (target === "security") {
           const { installSecurityIntoProject } = await loadProjectScaffoldModule();
           const result2 = await installSecurityIntoProject(context.projectRoot);
@@ -669,6 +746,19 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
         await runProjectLifecycleScript(context, context.projectRoot, "holo:build");
       }
     },
+    {
+      name: "start",
+      description: "Run the production framework server with Holo runtime preloads.",
+      usage: "holo start",
+      source: "internal",
+      async prepare() {
+        return { args: [], flags: {} };
+      },
+      async run() {
+        const runProjectStartServer = await resolveProjectExecutor(projectExecutors, "runProjectStartServer");
+        await runProjectStartServer(context, context.projectRoot);
+      }
+    },
     {
       name: "broadcast:work",
       description: "Run the self-hosted broadcast worker.",
@@ -1041,17 +1131,25 @@ function createInternalCommands(context, runtimeExecutor, queueExecutors = {}, p
         };
         if (isInteractive(context, input.flags)) {
           const noneSelected = [flags.migration, flags.observer, flags.seeder, flags.factory].every((value) => value !== true);
-          if (noneSelected && await confirm(context, "Generate a migration?", true)) {
-            flags.migration = true;
-          }
-          if (!flags.observer && await confirm(context, "Generate an observer?")) {
-            flags.observer = true;
-          }
-          if (!flags.seeder && await confirm(context, "Generate a seeder?")) {
-            flags.seeder = true;
-          }
-          if (!flags.factory && await confirm(context, "Generate a factory?")) {
-            flags.factory = true;
+          if (noneSelected) {
+            const selectedArtifacts = await promptMultiChoice(
+              context,
+              "Model artifacts",
+              MODEL_GENERATOR_OPTIONS,
+              {
+                initialValues: ["migration"],
+                labels: {
+                  migration: "Migration",
+                  observer: "Observer",
+                  seeder: "Seeder",
+                  factory: "Factory"
+                }
+              }
+            );
+            flags.migration = selectedArtifacts.includes("migration");
+            flags.observer = selectedArtifacts.includes("observer");
+            flags.seeder = selectedArtifacts.includes("seeder");
+            flags.factory = selectedArtifacts.includes("factory");
           }
         }
         return {

package/dist/broadcast-III5MB3R.mjs

@@ -0,0 +1,203 @@
+import {
+  initializeProjectRuntime
+} from "./chunk-KS5TWO75.mjs";
+import "./chunk-LBJAJLKU.mjs";
+import {
+  writeLine
+} from "./chunk-I7QBCEV7.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import {
+  prepareProjectDiscovery
+} from "./chunk-VP2E62DF.mjs";
+import "./chunk-MCVRN7KX.mjs";
+import {
+  loadProjectConfig
+} from "./chunk-YEFJBN56.mjs";
+import {
+  loadGeneratedProjectRegistry
+} from "./chunk-J76GH2DR.mjs";
+import {
+  importProjectModule,
+  resolveProjectPackageImportSpecifier
+} from "./chunk-ILU426CF.mjs";
+
+// src/broadcast.ts
+import { basename, extname, resolve } from "path";
+import { readFile } from "fs/promises";
+import { loadConfigDirectory } from "@holo-js/config";
+function hasLoadedRedisConfigSection(loadedFiles) {
+  return Array.isArray(loadedFiles) && loadedFiles.some((filePath) => {
+    return basename(filePath, extname(filePath)) === "redis";
+  });
+}
+async function hasProjectPackageDependency(projectRoot, packageName) {
+  try {
+    const manifest = JSON.parse(await readFile(resolve(projectRoot, "package.json"), "utf8"));
+    return Boolean(
+      manifest.dependencies?.[packageName] || manifest.devDependencies?.[packageName] || manifest.optionalDependencies?.[packageName] || manifest.peerDependencies?.[packageName]
+    );
+  } catch {
+    return false;
+  }
+}
+async function loadBroadcastCliModule(projectRoot) {
+  try {
+    return await import(resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/broadcast"));
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Unable to load @holo-js/broadcast from ${projectRoot}. Install it with "holo install broadcast". ${details}`
+    );
+  }
+}
+async function loadRealtimeServerModule(projectRoot) {
+  const specifier = resolveProjectPackageImportSpecifier(projectRoot, "@holo-js/realtime/server");
+  try {
+    return await import(specifier);
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    if (/Cannot find module|ERR_MODULE_NOT_FOUND|MODULE_NOT_FOUND/i.test(details) && details.includes(specifier)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function safeDecodeCookieSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function readCookieFromHeader(header, name) {
+  for (const segment of header?.split(";") ?? []) {
+    const separator = segment.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const cookieName = safeDecodeCookieSegment(segment.slice(0, separator).trim());
+    if (cookieName === name) {
+      return safeDecodeCookieSegment(segment.slice(separator + 1).trim());
+    }
+  }
+  return void 0;
+}
+function createRealtimeAuthRequestAccessors(headers) {
+  return {
+    async getCookie(name) {
+      return readCookieFromHeader(headers.get("cookie"), name);
+    },
+    async getHeader(name) {
+      return headers.get(name) ?? void 0;
+    },
+    async appendResponseCookie(_cookie) {
+    },
+    async redirectResponse(url) {
+      throw new Error(`Realtime auth attempted to redirect to "${url}". Realtime requests cannot redirect.`);
+    }
+  };
+}
+async function createRealtimeWorkerBindings(projectRoot) {
+  if (!await hasProjectPackageDependency(projectRoot, "@holo-js/realtime")) {
+    return void 0;
+  }
+  const realtime = await loadRealtimeServerModule(projectRoot);
+  if (!realtime) {
+    return void 0;
+  }
+  const runtime = await initializeProjectRuntime(projectRoot);
+  realtime.configureRealtimeRuntime?.({
+    async runWithAuthRequestAccessors(accessors, callback) {
+      const runner = runtime.runWithAuthRequestAccessors;
+      return runner ? await runner(accessors, callback) : await callback();
+    }
+  });
+  const definitions = /* @__PURE__ */ new Map();
+  const resolveDefinition = async (name) => {
+    const cached = definitions.get(name);
+    if (cached) {
+      return await cached;
+    }
+    const resolved = realtime.resolveRealtimeDefinition(name, {
+      projectRoot,
+      importModule: async (absolutePath) => await importProjectModule(projectRoot, absolutePath)
+    }).catch((error) => {
+      definitions.delete(name);
+      throw error;
+    });
+    definitions.set(name, resolved);
+    return await resolved;
+  };
+  const withRealtimeRequest = async (context, callback) => {
+    return await callback(createRealtimeAuthRequestAccessors(context.headers));
+  };
+  return {
+    async query(name, args, context) {
+      return await withRealtimeRequest(context, async (authRequest) => {
+        return await realtime.executeRealtimeQuery(await resolveDefinition(name), args, { authRequest });
+      });
+    },
+    async mutate(name, args, context) {
+      return await withRealtimeRequest(context, async (authRequest) => {
+        return await realtime.executeRealtimeMutation(await resolveDefinition(name), args, { authRequest });
+      });
+    },
+    async subscribe(name, args, options) {
+      return await withRealtimeRequest(options.context, async (authRequest) => {
+        return await realtime.subscribeRealtimeQuery(await resolveDefinition(name), args, {
+          onData: options.onData,
+          onError: options.onError
+        }, { authRequest });
+      });
+    }
+  };
+}
+async function runBroadcastWorkCommand(io, projectRoot, dependencies = {}) {
+  const loadConfig = dependencies.loadConfig ?? loadConfigDirectory;
+  const loadModule = dependencies.loadModule ?? loadBroadcastCliModule;
+  const config = await loadConfig(projectRoot);
+  const project = await loadProjectConfig(projectRoot);
+  const loadRegistry = dependencies.loadRegistry ?? loadGeneratedProjectRegistry;
+  await loadRegistry(projectRoot).catch(() => void 0);
+  const registry = await prepareProjectDiscovery(projectRoot, project.config);
+  const broadcastModule = await loadModule(projectRoot);
+  const realtime = await createRealtimeWorkerBindings(projectRoot);
+  const worker = await broadcastModule.startBroadcastWorker({
+    config: config.broadcast,
+    queue: config.queue,
+    ...hasLoadedRedisConfigSection(config.loadedFiles) ? { redis: config.redis } : {},
+    ...registry ? {
+      channelAuth: {
+        registry: {
+          projectRoot,
+          channels: registry.channels
+        },
+        importModule: async (absolutePath) => await importProjectModule(projectRoot, absolutePath)
+      }
+    } : {},
+    ...realtime ? { realtime } : {}
+  });
+  writeLine(io.stdout, `[broadcast] Worker listening on ${worker.host}:${worker.port}`);
+  await new Promise((resolvePromise) => {
+    let stopped = false;
+    const stop = async () => {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      await worker.stop();
+      resolvePromise();
+    };
+    const onSignal = () => {
+      void stop();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  });
+}
+export {
+  loadBroadcastCliModule,
+  runBroadcastWorkCommand
+};