@holo-js/broadcast 0.2.6 → 0.3.1

package/dist/auth.d.ts

@@ -1,5 +1,5 @@
 import { BroadcastChannelAuthRequest, BroadcastChannelAuthRuntimeBindings, BroadcastChannelAuthResult, GeneratedChannelAuthRegistryEntry, ChannelDefinition, BroadcastAuthEndpointPayload, BroadcastAuthEndpointOptions, BroadcastJsonObject, BroadcastWhisperValidationResult } from './contracts.js';
-import '@holo-js/config';
+import './config.js';
 import '@holo-js/validation';
 
 type LoadedChannelDefinitions = Readonly<Record<string, ChannelDefinition>>;
@@ -7,6 +7,7 @@ type MatchedChannelDefinition = {
     readonly definition: ChannelDefinition;
     readonly params: Readonly<Record<string, string>>;
 };
+declare function normalizeRegistryEntry(entry: GeneratedChannelAuthRegistryEntry): GeneratedChannelAuthRegistryEntry;
 declare function importChannelDefinition(entry: GeneratedChannelAuthRegistryEntry, bindings: BroadcastChannelAuthRuntimeBindings): Promise<ChannelDefinition>;
 declare function loadChannelDefinitions(bindings: BroadcastChannelAuthRuntimeBindings): Promise<LoadedChannelDefinitions>;
 declare function matchPattern(pattern: string, channel: string): Readonly<Record<string, string>> | null;
@@ -26,6 +27,7 @@ declare const broadcastAuthInternals: {
     importChannelDefinition: typeof importChannelDefinition;
     loadChannelDefinitions: typeof loadChannelDefinitions;
     matchPattern: typeof matchPattern;
+    normalizeRegistryEntry: typeof normalizeRegistryEntry;
     parseBroadcastAuthEndpointPayload: typeof parseBroadcastAuthEndpointPayload;
     resolveAuthDefinitions: typeof resolveAuthDefinitions;
     resolveChannelMatch: typeof resolveChannelMatch;

package/dist/auth.mjs

@@ -6,8 +6,9 @@ import {
   resolveBroadcastChannelGuard,
   resolveBroadcastWhisperSchema,
   validateBroadcastWhisperPayload
-} from "./chunk-U5JDBKXC.mjs";
-import "./chunk-TTKGDABI.mjs";
+} from "./chunk-JVDFH2TW.mjs";
+import "./chunk-6DCCSFFM.mjs";
+import "./chunk-XLUGF257.mjs";
 import "./chunk-HE6HN7ID.mjs";
 export {
   authorizeBroadcastChannel,

package/dist/{chunk-TTKGDABI.mjs → chunk-6DCCSFFM.mjs}

@@ -1,3 +1,6 @@
+import {
+  holoBroadcastDefaults
+} from "./chunk-XLUGF257.mjs";
 import {
   formatChannelPattern,
   isBroadcastDefinition,
@@ -8,7 +11,6 @@ import {
 
 // src/runtime.ts
 import { randomUUID } from "crypto";
-import { holoBroadcastDefaults } from "@holo-js/config";
 
 // src/registry.ts
 var registeredDrivers = /* @__PURE__ */ new Map();
@@ -36,6 +38,9 @@ function registerBroadcastDriver(name, driver, options = {}) {
 function getRegisteredBroadcastDriver(name) {
   return registeredDrivers.get(normalizeDriverName(name));
 }
+function unregisterBroadcastDriver(name) {
+  return registeredDrivers.delete(normalizeDriverName(name));
+}
 function listRegisteredBroadcastDrivers() {
   return Object.freeze(
     [...registeredDrivers.entries()].map(([name, driver]) => Object.freeze({ name, driver }))
@@ -48,6 +53,63 @@ var broadcastRegistryInternals = {
   normalizeDriverName
 };
 
+// src/plugins.ts
+import {
+  loadHoloPluginContributionModules,
+  loadHoloPluginDefinitions
+} from "@holo-js/kernel";
+var loadedProjectRoots = /* @__PURE__ */ new Set();
+var registeredPluginDrivers = /* @__PURE__ */ new Map();
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveBroadcastDriver(moduleValue, packageName, driverName) {
+  const candidate = isRecord(moduleValue) && typeof moduleValue.default !== "undefined" ? moduleValue.default : isRecord(moduleValue) && typeof moduleValue.driver !== "undefined" ? moduleValue.driver : moduleValue;
+  if (!isRecord(candidate) || typeof candidate.send !== "function") {
+    throw new Error(`[@holo-js/broadcast] Plugin ${packageName} broadcast driver "${driverName}" must export send().`);
+  }
+  return {
+    send: candidate.send
+  };
+}
+async function loadBroadcastPluginDrivers(projectRoot = process.cwd(), pluginNames = []) {
+  const root = projectRoot;
+  const loadKey = `${root}\0${[...pluginNames].sort().join("\0")}`;
+  if (loadedProjectRoots.has(loadKey)) {
+    return;
+  }
+  const plugins = await loadHoloPluginDefinitions(root, pluginNames);
+  const contributions = await loadHoloPluginContributionModules(root, plugins, "broadcast", "drivers");
+  for (const contribution of contributions) {
+    const previous = getRegisteredBroadcastDriver(contribution.name);
+    const driver = resolveBroadcastDriver(contribution.module, contribution.plugin.packageName, contribution.name);
+    const registered = registerBroadcastDriver(
+      contribution.name,
+      driver,
+      { replace: true }
+    );
+    const existingPluginDriver = registeredPluginDrivers.get(registered.name);
+    registeredPluginDrivers.set(registered.name, {
+      driver,
+      previous: existingPluginDriver ? existingPluginDriver.previous : previous
+    });
+  }
+  loadedProjectRoots.add(loadKey);
+}
+function resetBroadcastPluginDrivers() {
+  for (const [driverName, registered] of registeredPluginDrivers) {
+    if (getRegisteredBroadcastDriver(driverName) !== registered.driver) {
+      continue;
+    }
+    unregisterBroadcastDriver(driverName);
+    if (registered.previous) {
+      registerBroadcastDriver(driverName, registered.previous, { replace: true });
+    }
+  }
+  loadedProjectRoots.clear();
+  registeredPluginDrivers.clear();
+}
+
 // src/runtime.ts
 var HOLO_BROADCAST_DELIVER_JOB = "holo.broadcast.deliver";
 function getRuntimeState() {
@@ -272,7 +334,7 @@ function resolveDriver(connectionName) {
   });
 }
 async function runQueuedBroadcastDelivery(payload) {
-  const driver = resolveDriver(payload.context.connection);
+  const driver = await resolveDriverWithPluginFallback(payload.context.connection);
   const context = createExecutionContext(payload.messageId, driver, true);
   return await deliverResolvedRawBroadcast(payload.raw, driver, context);
 }
@@ -358,7 +420,7 @@ async function deliverResolvedRawBroadcast(input, driver, context) {
   return normalizeDriverResult(result, context, frozenInput.channels);
 }
 async function executeResolvedRawBroadcast(input, definition, options) {
-  const driver = resolveDriver(input.connection);
+  const driver = await resolveDriverWithPluginFallback(input.connection);
   const plan = resolveQueuePlan(definition, options);
   const context = createExecutionContext(randomUUID(), driver, plan.queued);
   if (plan.afterCommit) {
@@ -440,7 +502,18 @@ var PendingDispatch = class {
   }
 };
 function configureBroadcastRuntime(bindings) {
-  getRuntimeState().bindings = bindings;
+  const state = getRuntimeState();
+  if (!bindings) {
+    state.bindings = void 0;
+    state.projectRoot = void 0;
+    state.pluginNames = void 0;
+    return;
+  }
+  const { projectRoot, plugins, ...runtimeBindings } = bindings;
+  state.bindings = runtimeBindings;
+  const normalizedProjectRoot = typeof projectRoot === "string" ? projectRoot.trim() : "";
+  state.projectRoot = normalizedProjectRoot ? normalizedProjectRoot : void 0;
+  state.pluginNames = Object.freeze([...new Set((plugins ?? []).map((plugin) => plugin.trim()).filter((plugin) => plugin.length > 0))]);
 }
 function getBroadcastRuntimeBindings() {
   return getRuntimeBindings();
@@ -448,9 +521,27 @@ function getBroadcastRuntimeBindings() {
 function resetBroadcastRuntime() {
   const state = getRuntimeState();
   state.bindings = void 0;
+  state.projectRoot = void 0;
+  state.pluginNames = void 0;
   state.loadQueueModule = void 0;
   state.loadDbModule = void 0;
   state.queueJobRegistration = void 0;
+  resetBroadcastPluginDrivers();
+}
+function isBroadcastDriverNotRegisteredError(error) {
+  return error instanceof Error && error.message.startsWith('[@holo-js/broadcast] Broadcast driver "') && error.message.endsWith('" is not registered.');
+}
+async function resolveDriverWithPluginFallback(connectionName) {
+  try {
+    return resolveDriver(connectionName);
+  } catch (error) {
+    if (!isBroadcastDriverNotRegisteredError(error)) {
+      throw error;
+    }
+  }
+  const state = getRuntimeState();
+  await loadBroadcastPluginDrivers(state.projectRoot, state.pluginNames);
+  return resolveDriver(connectionName);
 }
 function broadcast(definition) {
   return new PendingDispatch(async (options) => {
@@ -497,6 +588,8 @@ export {
   listRegisteredBroadcastDrivers,
   resetBroadcastDriverRegistry,
   broadcastRegistryInternals,
+  loadBroadcastPluginDrivers,
+  resetBroadcastPluginDrivers,
   configureBroadcastRuntime,
   getBroadcastRuntimeBindings,
   resetBroadcastRuntime,

package/dist/{chunk-U5JDBKXC.mjs → chunk-JVDFH2TW.mjs}

@@ -1,6 +1,6 @@
 import {
   getBroadcastRuntimeBindings
-} from "./chunk-TTKGDABI.mjs";
+} from "./chunk-6DCCSFFM.mjs";
 import {
   isChannelDefinition,
   isPlainObject,
@@ -348,8 +348,7 @@ function jsonResponse(body, status) {
   });
 }
 function signBroadcastAuth(appSecret, socketId, channel, channelData) {
-  const value = channelData ? `${socketId}:${channel}:${channelData}` : `${socketId}:${channel}`;
-  return createHmac("sha256", appSecret).update(value).digest("hex");
+  return createHmac("sha256", appSecret).update(`${socketId}:${channel}:${channelData}`).digest("hex");
 }
 async function renderBroadcastAuthResponse(request, options = {}) {
   let payload;
@@ -422,6 +421,7 @@ var broadcastAuthInternals = {
   importChannelDefinition,
   loadChannelDefinitions,
   matchPattern,
+  normalizeRegistryEntry,
   parseBroadcastAuthEndpointPayload,
   resolveAuthDefinitions,
   resolveChannelMatch,

package/dist/chunk-XLUGF257.mjs

@@ -0,0 +1,268 @@
+// src/config.ts
+import { registerConfigNormalizer } from "@holo-js/config/registry";
+var DEFAULT_BROADCAST_CONNECTION = "null";
+var DEFAULT_BROADCAST_HOST = "127.0.0.1";
+var DEFAULT_BROADCAST_HTTP_PORT = 80;
+var DEFAULT_BROADCAST_HTTPS_PORT = 443;
+var DEFAULT_BROADCAST_PORT = DEFAULT_BROADCAST_HTTPS_PORT;
+var DEFAULT_BROADCAST_WORKER_HOST = "0.0.0.0";
+var DEFAULT_BROADCAST_WORKER_PORT = 8080;
+var DEFAULT_BROADCAST_WORKER_PATH = "/app";
+var DEFAULT_BROADCAST_HEALTH_PATH = "/health";
+var DEFAULT_BROADCAST_STATS_PATH = "/stats";
+var DEFAULT_BROADCAST_MAX_REQUEST_BYTES = 1048576;
+var DEFAULT_BROADCAST_MAX_MESSAGE_BYTES = 65536;
+var holoBroadcastDefaults = Object.freeze({
+  default: DEFAULT_BROADCAST_CONNECTION,
+  connections: Object.freeze({
+    log: Object.freeze({
+      name: "log",
+      driver: "log",
+      clientOptions: Object.freeze({})
+    }),
+    null: Object.freeze({
+      name: "null",
+      driver: "null",
+      clientOptions: Object.freeze({})
+    })
+  }),
+  worker: Object.freeze({
+    host: DEFAULT_BROADCAST_WORKER_HOST,
+    port: DEFAULT_BROADCAST_WORKER_PORT,
+    path: DEFAULT_BROADCAST_WORKER_PATH,
+    publicHost: void 0,
+    publicPort: void 0,
+    publicScheme: "https",
+    healthPath: DEFAULT_BROADCAST_HEALTH_PATH,
+    statsPath: DEFAULT_BROADCAST_STATS_PATH,
+    allowedOrigins: Object.freeze(["https://127.0.0.1"]),
+    maxRequestBytes: DEFAULT_BROADCAST_MAX_REQUEST_BYTES,
+    maxMessageBytes: DEFAULT_BROADCAST_MAX_MESSAGE_BYTES,
+    statsEnabled: false,
+    scaling: false
+  })
+});
+function parseInteger(value, label) {
+  const normalized = typeof value === "number" ? value : value.trim() ? Number(value.trim()) : Number.NaN;
+  if (!Number.isFinite(normalized) || !Number.isInteger(normalized)) throw new Error(`[Holo Broadcast] ${label} must be an integer.`);
+  if (normalized < 1) throw new Error(`[Holo Broadcast] ${label} must be greater than or equal to 1.`);
+  return normalized;
+}
+function normalizeOptionalBroadcastString(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  if (!normalized) {
+    throw new Error(`[Holo Broadcast] ${label} must be a non-empty string when provided.`);
+  }
+  return normalized;
+}
+function normalizeBroadcastPort(value, fallback, label) {
+  const normalized = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value.trim()) : fallback;
+  if (!Number.isInteger(normalized) || normalized <= 0) {
+    throw new Error(`[Holo Broadcast] ${label} must be a positive integer.`);
+  }
+  return normalized;
+}
+function normalizeBroadcastScheme(value, fallback, label) {
+  const normalized = normalizeOptionalBroadcastString(value, label)?.toLowerCase();
+  if (typeof normalized === "undefined") {
+    return fallback;
+  }
+  if (normalized !== "http" && normalized !== "https") {
+    throw new Error(`[Holo Broadcast] ${label} must be "http" or "https".`);
+  }
+  return normalized;
+}
+function normalizeBroadcastConnectionOptions(options, fallbackHost, label) {
+  const scheme = normalizeBroadcastScheme(
+    options?.scheme,
+    options?.useTLS === false ? "http" : "https",
+    `${label} scheme`
+  );
+  const resolvedFallbackPort = scheme === "http" ? DEFAULT_BROADCAST_HTTP_PORT : DEFAULT_BROADCAST_HTTPS_PORT;
+  return Object.freeze({
+    host: normalizeOptionalBroadcastString(options?.host, `${label} host`) ?? fallbackHost,
+    port: normalizeBroadcastPort(options?.port, resolvedFallbackPort, `${label} port`),
+    scheme,
+    useTLS: options?.useTLS ?? scheme === "https",
+    cluster: normalizeOptionalBroadcastString(options?.cluster, `${label} cluster`) ?? void 0
+  });
+}
+function normalizeBroadcastWorkerConfig(worker, connectionOptions, configuredConnectionPort) {
+  const scaling = worker?.scaling;
+  const publicScheme = normalizeBroadcastScheme(worker?.publicScheme, connectionOptions?.scheme ?? "https", "Broadcast worker public scheme");
+  const fallbackPort = typeof configuredConnectionPort === "undefined" ? DEFAULT_BROADCAST_WORKER_PORT : normalizeBroadcastPort(configuredConnectionPort, DEFAULT_BROADCAST_WORKER_PORT, "Broadcast worker port");
+  if (scaling && scaling.driver !== "redis") {
+    throw new Error('[Holo Broadcast] Broadcast worker scaling driver must be "redis".');
+  }
+  const publicHost = normalizeOptionalBroadcastString(worker?.publicHost, "Broadcast worker public host") ?? void 0;
+  const publicPort = typeof worker?.publicPort === "undefined" ? publicScheme === "http" ? DEFAULT_BROADCAST_HTTP_PORT : void 0 : normalizeBroadcastPort(
+    worker.publicPort,
+    publicScheme === "http" ? DEFAULT_BROADCAST_HTTP_PORT : DEFAULT_BROADCAST_HTTPS_PORT,
+    "Broadcast worker public port"
+  );
+  const defaultOriginPort = publicPort ?? connectionOptions?.port;
+  const defaultOriginHost = publicHost ?? connectionOptions?.host ?? "127.0.0.1";
+  const defaultOrigin = new URL(`${publicScheme}://${defaultOriginHost}${typeof defaultOriginPort === "number" ? `:${defaultOriginPort}` : ""}`).origin;
+  const allowedOrigins = worker?.allowedOrigins?.map((value, index) => {
+    const normalized = value.trim();
+    if (normalized === "*") {
+      return normalized;
+    }
+    let origin;
+    try {
+      origin = new URL(normalized).origin;
+    } catch {
+      throw new Error(`[Holo Broadcast] Broadcast worker allowed origin at index ${index} must be "*" or an absolute URL origin.`);
+    }
+    if (origin === "null" || normalized.replace(/\/$/, "") !== origin) {
+      throw new Error(`[Holo Broadcast] Broadcast worker allowed origin at index ${index} must not include a path, query, or fragment.`);
+    }
+    return origin;
+  }) ?? [defaultOrigin];
+  return Object.freeze({
+    host: normalizeOptionalBroadcastString(worker?.host, "Broadcast worker host") ?? DEFAULT_BROADCAST_WORKER_HOST,
+    port: normalizeBroadcastPort(worker?.port, fallbackPort, "Broadcast worker port"),
+    path: normalizeOptionalBroadcastString(worker?.path, "Broadcast worker path") ?? DEFAULT_BROADCAST_WORKER_PATH,
+    publicHost,
+    publicPort,
+    publicScheme,
+    healthPath: normalizeOptionalBroadcastString(worker?.healthPath, "Broadcast worker health path") ?? DEFAULT_BROADCAST_HEALTH_PATH,
+    statsPath: normalizeOptionalBroadcastString(worker?.statsPath, "Broadcast worker stats path") ?? DEFAULT_BROADCAST_STATS_PATH,
+    allowedOrigins: Object.freeze(allowedOrigins),
+    maxRequestBytes: parseInteger(worker?.maxRequestBytes ?? DEFAULT_BROADCAST_MAX_REQUEST_BYTES, "broadcast worker maxRequestBytes"),
+    maxMessageBytes: parseInteger(worker?.maxMessageBytes ?? DEFAULT_BROADCAST_MAX_MESSAGE_BYTES, "broadcast worker maxMessageBytes"),
+    statsEnabled: worker?.statsEnabled ?? false,
+    scaling: scaling && typeof scaling === "object" ? Object.freeze({
+      driver: "redis",
+      connection: normalizeOptionalBroadcastString(scaling.connection, "Broadcast worker scaling connection") ?? "default"
+    }) : holoBroadcastDefaults.worker.scaling
+  });
+}
+function normalizeBroadcastConnection(name, connection) {
+  const normalizedName = normalizeOptionalBroadcastString(name, "Broadcast connection name");
+  const driver = normalizeOptionalBroadcastString(connection.driver, `Broadcast connection "${name}" driver`);
+  if (!normalizedName || !driver) {
+    throw new Error("[Holo Broadcast] Broadcast connections must define a name and driver.");
+  }
+  const clientOptions = Object.freeze({
+    ...connection.clientOptions ?? {}
+  });
+  if (driver === "holo") {
+    return Object.freeze({
+      name: normalizedName,
+      driver: "holo",
+      key: normalizeOptionalBroadcastString(connection.key, `Broadcast connection "${name}" key`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define a key.`);
+      })(),
+      secret: normalizeOptionalBroadcastString(connection.secret, `Broadcast connection "${name}" secret`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define a secret.`);
+      })(),
+      appId: normalizeOptionalBroadcastString(connection.appId, `Broadcast connection "${name}" appId`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define an appId.`);
+      })(),
+      options: normalizeBroadcastConnectionOptions(connection.options, DEFAULT_BROADCAST_HOST, `Broadcast connection "${name}" options`),
+      clientOptions
+    });
+  }
+  if (driver === "pusher") {
+    const cluster = normalizeOptionalBroadcastString(connection.options?.cluster, `Broadcast connection "${name}" cluster`) ?? void 0;
+    return Object.freeze({
+      name: normalizedName,
+      driver: "pusher",
+      key: normalizeOptionalBroadcastString(connection.key, `Broadcast connection "${name}" key`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define a key.`);
+      })(),
+      secret: normalizeOptionalBroadcastString(connection.secret, `Broadcast connection "${name}" secret`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define a secret.`);
+      })(),
+      appId: normalizeOptionalBroadcastString(connection.appId, `Broadcast connection "${name}" appId`) ?? (() => {
+        throw new Error(`[Holo Broadcast] Broadcast connection "${name}" must define an appId.`);
+      })(),
+      options: normalizeBroadcastConnectionOptions(
+        {
+          ...connection.options,
+          cluster
+        },
+        normalizeOptionalBroadcastString(connection.options?.host, `Broadcast connection "${name}" host`) ?? (cluster ? `api-${cluster}.pusher.com` : "api-mt1.pusher.com"),
+        `Broadcast connection "${name}" options`
+      ),
+      clientOptions
+    });
+  }
+  if (driver === "log") {
+    return Object.freeze({
+      name: normalizedName,
+      driver: "log",
+      clientOptions
+    });
+  }
+  if (driver === "null") {
+    return Object.freeze({
+      name: normalizedName,
+      driver: "null",
+      clientOptions
+    });
+  }
+  if (driver === "ably") {
+    throw new Error('[Holo Broadcast] Broadcast driver "ably" is not supported yet.');
+  }
+  const {
+    driver: _ignoredDriver,
+    clientOptions: _ignoredClientOptions,
+    ...customConfig
+  } = connection;
+  return Object.freeze({
+    driver,
+    clientOptions,
+    ...customConfig,
+    name: normalizedName
+  });
+}
+function normalizeBroadcastConfig(config = {}) {
+  const normalizedConnections = Object.fromEntries(
+    Object.entries(config.connections ?? holoBroadcastDefaults.connections).map(([name, connection]) => [name, normalizeBroadcastConnection(name, connection)])
+  );
+  const defaultConnection = normalizeOptionalBroadcastString(config.default, "Default broadcast connection") ?? holoBroadcastDefaults.default;
+  if (!normalizedConnections[defaultConnection]) {
+    throw new Error(
+      `[Holo Broadcast] default broadcast connection "${defaultConnection}" is not configured. Available connections: ${Object.keys(normalizedConnections).join(", ")}`
+    );
+  }
+  const defaultBroadcastConnection = normalizedConnections[defaultConnection];
+  const defaultHoloConnectionOptions = defaultBroadcastConnection && defaultBroadcastConnection.driver === "holo" && "options" in defaultBroadcastConnection ? defaultBroadcastConnection.options : void 0;
+  const configuredDefaultConnection = config.connections?.[defaultConnection];
+  const configuredDefaultHoloConnectionPort = configuredDefaultConnection?.driver === "holo" ? configuredDefaultConnection.options?.port : void 0;
+  return Object.freeze({
+    default: defaultConnection,
+    connections: Object.freeze(normalizedConnections),
+    worker: normalizeBroadcastWorkerConfig(config.worker, defaultHoloConnectionOptions, configuredDefaultHoloConnectionPort)
+  });
+}
+function defineBroadcastConfig(config) {
+  return Object.freeze({ ...config });
+}
+registerConfigNormalizer({
+  name: "broadcast",
+  normalize: normalizeBroadcastConfig
+});
+
+export {
+  DEFAULT_BROADCAST_CONNECTION,
+  DEFAULT_BROADCAST_HOST,
+  DEFAULT_BROADCAST_HTTP_PORT,
+  DEFAULT_BROADCAST_HTTPS_PORT,
+  DEFAULT_BROADCAST_PORT,
+  DEFAULT_BROADCAST_WORKER_HOST,
+  DEFAULT_BROADCAST_WORKER_PORT,
+  DEFAULT_BROADCAST_WORKER_PATH,
+  DEFAULT_BROADCAST_HEALTH_PATH,
+  DEFAULT_BROADCAST_STATS_PATH,
+  DEFAULT_BROADCAST_MAX_REQUEST_BYTES,
+  DEFAULT_BROADCAST_MAX_MESSAGE_BYTES,
+  holoBroadcastDefaults,
+  normalizeBroadcastConfig,
+  defineBroadcastConfig
+};

package/dist/client-config.d.ts

@@ -1,4 +1,4 @@
-import { LoadedHoloConfig } from '@holo-js/config';
+import { NormalizedHoloBroadcastConfig } from './config.js';
 
 type BroadcastClientConfig = {
     readonly key: string;
@@ -8,7 +8,7 @@ type BroadcastClientConfig = {
     readonly scheme: 'http' | 'https';
     readonly authEndpoint?: string;
 };
-declare function resolveBroadcastClientConfig(config: LoadedHoloConfig['broadcast']): BroadcastClientConfig;
-declare function renderBroadcastClientConfigResponse(config: LoadedHoloConfig['broadcast']): Response;
+declare function resolveBroadcastClientConfig(config: NormalizedHoloBroadcastConfig): BroadcastClientConfig;
+declare function renderBroadcastClientConfigResponse(config: NormalizedHoloBroadcastConfig): Response;
 
 export { type BroadcastClientConfig, renderBroadcastClientConfigResponse, resolveBroadcastClientConfig };

package/dist/config.d.ts

@@ -0,0 +1,138 @@
+type BroadcastConnectionDriver = 'holo' | 'pusher' | 'log' | 'null';
+type BroadcastConnectionScheme = 'http' | 'https';
+interface BroadcastConnectionOptionsConfig {
+    readonly host?: string;
+    readonly port?: number | string;
+    readonly scheme?: BroadcastConnectionScheme;
+    readonly useTLS?: boolean;
+    readonly cluster?: string;
+}
+interface BroadcastWorkerScalingConfig {
+    readonly driver: 'redis';
+    readonly connection?: string;
+}
+interface BroadcastWorkerConfig {
+    readonly host?: string;
+    readonly port?: number | string;
+    readonly path?: string;
+    readonly publicHost?: string;
+    readonly publicPort?: number | string;
+    readonly publicScheme?: BroadcastConnectionScheme;
+    readonly healthPath?: string;
+    readonly statsPath?: string;
+    readonly allowedOrigins?: readonly string[];
+    readonly maxRequestBytes?: number | string;
+    readonly maxMessageBytes?: number | string;
+    readonly statsEnabled?: boolean;
+    readonly scaling?: false | BroadcastWorkerScalingConfig;
+}
+type BroadcastConnectionConfigValue = string | number | boolean | object | undefined;
+interface BaseBroadcastConnectionConfig {
+    readonly driver: BroadcastConnectionDriver | (string & {});
+    readonly options?: BroadcastConnectionOptionsConfig;
+    readonly clientOptions?: Readonly<Record<string, unknown>>;
+    readonly [key: string]: BroadcastConnectionConfigValue;
+}
+interface HoloBroadcastConnectionConfig extends BaseBroadcastConnectionConfig {
+    readonly driver: 'holo';
+    readonly key?: string;
+    readonly secret?: string;
+    readonly appId?: string | number;
+}
+interface PusherBroadcastConnectionConfig extends BaseBroadcastConnectionConfig {
+    readonly driver: 'pusher';
+    readonly key?: string;
+    readonly secret?: string;
+    readonly appId?: string | number;
+}
+interface LogBroadcastConnectionConfig extends BaseBroadcastConnectionConfig {
+    readonly driver: 'log';
+}
+interface NullBroadcastConnectionConfig extends BaseBroadcastConnectionConfig {
+    readonly driver: 'null';
+}
+type HoloBroadcastConnection = HoloBroadcastConnectionConfig | PusherBroadcastConnectionConfig | LogBroadcastConnectionConfig | NullBroadcastConnectionConfig | BaseBroadcastConnectionConfig;
+interface HoloBroadcastConfig {
+    readonly default?: string;
+    readonly connections?: Readonly<Record<string, HoloBroadcastConnection>>;
+    readonly worker?: BroadcastWorkerConfig;
+}
+interface NormalizedBroadcastConnectionOptionsConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly scheme: BroadcastConnectionScheme;
+    readonly useTLS: boolean;
+    readonly cluster?: string;
+}
+interface NormalizedBroadcastWorkerScalingConfig {
+    readonly driver: 'redis';
+    readonly connection: string;
+}
+interface NormalizedBroadcastWorkerConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly path: string;
+    readonly publicHost?: string;
+    readonly publicPort?: number;
+    readonly publicScheme: BroadcastConnectionScheme;
+    readonly healthPath: string;
+    readonly statsPath: string;
+    readonly allowedOrigins: readonly string[];
+    readonly maxRequestBytes: number;
+    readonly maxMessageBytes: number;
+    readonly statsEnabled: boolean;
+    readonly scaling: false | NormalizedBroadcastWorkerScalingConfig;
+}
+interface NormalizedBaseBroadcastConnectionConfig {
+    readonly name: string;
+    readonly driver: string;
+    readonly clientOptions: Readonly<Record<string, unknown>>;
+}
+interface NormalizedHoloBroadcastConnectionConfig extends NormalizedBaseBroadcastConnectionConfig {
+    readonly driver: 'holo';
+    readonly key: string;
+    readonly secret: string;
+    readonly appId: string;
+    readonly options: NormalizedBroadcastConnectionOptionsConfig;
+}
+interface NormalizedPusherBroadcastConnectionConfig extends NormalizedBaseBroadcastConnectionConfig {
+    readonly driver: 'pusher';
+    readonly key: string;
+    readonly secret: string;
+    readonly appId: string;
+    readonly options: NormalizedBroadcastConnectionOptionsConfig;
+}
+interface NormalizedLogBroadcastConnectionConfig extends NormalizedBaseBroadcastConnectionConfig {
+    readonly driver: 'log';
+}
+interface NormalizedNullBroadcastConnectionConfig extends NormalizedBaseBroadcastConnectionConfig {
+    readonly driver: 'null';
+}
+type NormalizedHoloBroadcastConnection = NormalizedHoloBroadcastConnectionConfig | NormalizedPusherBroadcastConnectionConfig | NormalizedLogBroadcastConnectionConfig | NormalizedNullBroadcastConnectionConfig | NormalizedBaseBroadcastConnectionConfig;
+interface NormalizedHoloBroadcastConfig {
+    readonly default: string;
+    readonly connections: Readonly<Record<string, NormalizedHoloBroadcastConnection>>;
+    readonly worker: NormalizedBroadcastWorkerConfig;
+}
+declare const DEFAULT_BROADCAST_CONNECTION = "null";
+declare const DEFAULT_BROADCAST_HOST = "127.0.0.1";
+declare const DEFAULT_BROADCAST_HTTP_PORT = 80;
+declare const DEFAULT_BROADCAST_HTTPS_PORT = 443;
+declare const DEFAULT_BROADCAST_PORT = 443;
+declare const DEFAULT_BROADCAST_WORKER_HOST = "0.0.0.0";
+declare const DEFAULT_BROADCAST_WORKER_PORT = 8080;
+declare const DEFAULT_BROADCAST_WORKER_PATH = "/app";
+declare const DEFAULT_BROADCAST_HEALTH_PATH = "/health";
+declare const DEFAULT_BROADCAST_STATS_PATH = "/stats";
+declare const DEFAULT_BROADCAST_MAX_REQUEST_BYTES = 1048576;
+declare const DEFAULT_BROADCAST_MAX_MESSAGE_BYTES = 65536;
+declare const holoBroadcastDefaults: Readonly<NormalizedHoloBroadcastConfig>;
+declare function normalizeBroadcastConfig(config?: HoloBroadcastConfig): NormalizedHoloBroadcastConfig;
+declare function defineBroadcastConfig<TConfig extends HoloBroadcastConfig>(config: TConfig): Readonly<TConfig>;
+declare module '@holo-js/config' {
+    interface HoloConfigRegistry {
+        broadcast: NormalizedHoloBroadcastConfig;
+    }
+}
+
+export { type BaseBroadcastConnectionConfig, type BroadcastConnectionConfigValue, type BroadcastConnectionDriver, type BroadcastConnectionOptionsConfig, type BroadcastConnectionScheme, type BroadcastWorkerConfig, type BroadcastWorkerScalingConfig, DEFAULT_BROADCAST_CONNECTION, DEFAULT_BROADCAST_HEALTH_PATH, DEFAULT_BROADCAST_HOST, DEFAULT_BROADCAST_HTTPS_PORT, DEFAULT_BROADCAST_HTTP_PORT, DEFAULT_BROADCAST_MAX_MESSAGE_BYTES, DEFAULT_BROADCAST_MAX_REQUEST_BYTES, DEFAULT_BROADCAST_PORT, DEFAULT_BROADCAST_STATS_PATH, DEFAULT_BROADCAST_WORKER_HOST, DEFAULT_BROADCAST_WORKER_PATH, DEFAULT_BROADCAST_WORKER_PORT, type HoloBroadcastConfig, type HoloBroadcastConnection, type HoloBroadcastConnectionConfig, type LogBroadcastConnectionConfig, type NormalizedBaseBroadcastConnectionConfig, type NormalizedBroadcastConnectionOptionsConfig, type NormalizedBroadcastWorkerConfig, type NormalizedBroadcastWorkerScalingConfig, type NormalizedHoloBroadcastConfig, type NormalizedHoloBroadcastConnection, type NormalizedHoloBroadcastConnectionConfig, type NormalizedLogBroadcastConnectionConfig, type NormalizedNullBroadcastConnectionConfig, type NormalizedPusherBroadcastConnectionConfig, type NullBroadcastConnectionConfig, type PusherBroadcastConnectionConfig, defineBroadcastConfig, holoBroadcastDefaults, normalizeBroadcastConfig };

package/dist/config.mjs

@@ -0,0 +1,34 @@
+import {
+  DEFAULT_BROADCAST_CONNECTION,
+  DEFAULT_BROADCAST_HEALTH_PATH,
+  DEFAULT_BROADCAST_HOST,
+  DEFAULT_BROADCAST_HTTPS_PORT,
+  DEFAULT_BROADCAST_HTTP_PORT,
+  DEFAULT_BROADCAST_MAX_MESSAGE_BYTES,
+  DEFAULT_BROADCAST_MAX_REQUEST_BYTES,
+  DEFAULT_BROADCAST_PORT,
+  DEFAULT_BROADCAST_STATS_PATH,
+  DEFAULT_BROADCAST_WORKER_HOST,
+  DEFAULT_BROADCAST_WORKER_PATH,
+  DEFAULT_BROADCAST_WORKER_PORT,
+  defineBroadcastConfig,
+  holoBroadcastDefaults,
+  normalizeBroadcastConfig
+} from "./chunk-XLUGF257.mjs";
+export {
+  DEFAULT_BROADCAST_CONNECTION,
+  DEFAULT_BROADCAST_HEALTH_PATH,
+  DEFAULT_BROADCAST_HOST,
+  DEFAULT_BROADCAST_HTTPS_PORT,
+  DEFAULT_BROADCAST_HTTP_PORT,
+  DEFAULT_BROADCAST_MAX_MESSAGE_BYTES,
+  DEFAULT_BROADCAST_MAX_REQUEST_BYTES,
+  DEFAULT_BROADCAST_PORT,
+  DEFAULT_BROADCAST_STATS_PATH,
+  DEFAULT_BROADCAST_WORKER_HOST,
+  DEFAULT_BROADCAST_WORKER_PATH,
+  DEFAULT_BROADCAST_WORKER_PORT,
+  defineBroadcastConfig,
+  holoBroadcastDefaults,
+  normalizeBroadcastConfig
+};