@holo-js/broadcast 0.1.3

package/dist/index.mjs

@@ -0,0 +1,1445 @@
+import {
+  authorizeBroadcastChannel,
+  broadcastAuthInternals,
+  parseBroadcastAuthEndpointPayload,
+  renderBroadcastAuthResponse,
+  resolveBroadcastWhisperSchema,
+  validateBroadcastWhisperPayload
+} from "./chunk-5XRABYQH.mjs";
+import {
+  broadcast,
+  broadcastRaw,
+  broadcastRegistryInternals,
+  broadcastRuntimeInternals,
+  configureBroadcastRuntime,
+  getBroadcastRuntime,
+  getBroadcastRuntimeBindings,
+  getRegisteredBroadcastDriver,
+  listRegisteredBroadcastDrivers,
+  registerBroadcastDriver,
+  resetBroadcastDriverRegistry,
+  resetBroadcastRuntime
+} from "./chunk-742LGR5P.mjs";
+import {
+  broadcastInternals,
+  channel,
+  defineBroadcast,
+  defineChannel,
+  isBroadcastDefinition,
+  isChannelDefinition,
+  presenceChannel,
+  privateChannel
+} from "./chunk-QW6MHEWS.mjs";
+
+// src/worker.ts
+import { createHash, createHmac, randomInt, randomUUID } from "crypto";
+import { createServer } from "http";
+var MAX_PUBLISH_TIMESTAMP_SKEW_SECONDS = 300;
+function normalizeRequiredString(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`[@holo-js/broadcast] ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseJsonObject(value, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error(`[@holo-js/broadcast] ${label} must be valid JSON.`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`[@holo-js/broadcast] ${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function parseSocketMessage(rawMessage) {
+  const message = parseJsonObject(rawMessage, "Websocket message");
+  const event = normalizeRequiredString(String(message.event ?? ""), "Websocket event");
+  const channel2 = typeof message.channel === "string" ? normalizeRequiredString(message.channel, "Websocket channel") : void 0;
+  const data = typeof message.data === "string" ? parseJsonObject(message.data, "Websocket message data") : message.data && typeof message.data === "object" && !Array.isArray(message.data) ? message.data : {};
+  return Object.freeze({
+    event,
+    ...typeof channel2 === "undefined" ? {} : { channel: channel2 },
+    data
+  });
+}
+function normalizePublishBody(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("[@holo-js/broadcast] Publish payload must be a JSON object.");
+  }
+  const body = value;
+  const name = typeof body.name === "string" ? normalizeRequiredString(body.name, "Publish name") : typeof body.event === "string" ? normalizeRequiredString(body.event, "Publish event") : "";
+  if (!name) {
+    throw new Error("[@holo-js/broadcast] Publish payload must include an event name.");
+  }
+  const channels = Array.isArray(body.channels) ? body.channels.map((channel2) => {
+    if (typeof channel2 !== "string") {
+      throw new Error("[@holo-js/broadcast] Publish channel must be a non-empty string.");
+    }
+    return normalizeRequiredString(channel2, "Publish channel");
+  }) : typeof body.channel === "string" ? [normalizeRequiredString(body.channel, "Publish channel")] : [];
+  if (channels.length === 0) {
+    throw new Error("[@holo-js/broadcast] Publish payload must include at least one channel.");
+  }
+  const data = typeof body.data === "string" ? body.data : JSON.stringify(body.data ?? {});
+  const socketId = typeof body.socket_id === "string" ? normalizeRequiredString(body.socket_id, "Publish socket_id") : void 0;
+  return Object.freeze({
+    name,
+    channels: Object.freeze(channels),
+    data,
+    ...typeof socketId === "undefined" ? {} : { socket_id: socketId }
+  });
+}
+function createPusherSignature(secret, method, pathname, params) {
+  const sorted = [...params.entries()].filter(([key]) => key !== "auth_signature").sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+  const payload = `${method.toUpperCase()}
+${pathname}
+${sorted}`;
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+function logSocketMessageError(socketId, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[@holo-js/broadcast] WebSocket message handling failed for socket "${socketId}": ${message}`);
+}
+function logScalingMessageError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[@holo-js/broadcast] Scaling message handling failed: ${message}`);
+}
+function logSocketCleanupError(socketId, channel2, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[@holo-js/broadcast] Socket cleanup failed for socket "${socketId}" on "${channel2}": ${message}`);
+}
+function parseChannelKind(channel2) {
+  if (channel2.startsWith("private-")) {
+    return Object.freeze({
+      kind: "private",
+      canonical: channel2.slice("private-".length)
+    });
+  }
+  if (channel2.startsWith("presence-")) {
+    return Object.freeze({
+      kind: "presence",
+      canonical: channel2.slice("presence-".length)
+    });
+  }
+  return Object.freeze({
+    kind: "public",
+    canonical: channel2
+  });
+}
+function createSocketId() {
+  return `${randomInt(1, 999999)}.${randomInt(1, 999999)}`;
+}
+function createScalingNodeId() {
+  return normalizeRequiredString(`${process.env.HOSTNAME ?? "node"}-${randomUUID()}`, "Broadcast worker node id");
+}
+function resolveScalingEventChannel(connection) {
+  return `holo:broadcast:scaling:${connection}:events`;
+}
+function resolvePresenceHashKey(connection, appId, channel2) {
+  return `holo:broadcast:scaling:${connection}:presence:${appId}:${channel2}`;
+}
+function createNodeSocketRef(nodeId, socketId) {
+  return `${nodeId}:${socketId}`;
+}
+function composeSubscriptionKey(appId, channel2) {
+  return `${appId}:${channel2}`;
+}
+function resolvePresenceMemberId(member, fallback) {
+  const candidate = member.id;
+  if (typeof candidate === "string" || typeof candidate === "number") {
+    return String(candidate);
+  }
+  return fallback;
+}
+function serializePresenceMemberRemoved(member, fallback) {
+  return JSON.stringify({
+    user_id: resolvePresenceMemberId(member, fallback)
+  });
+}
+function normalizePresenceMemberMessage(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`[@holo-js/broadcast] ${label} must be a JSON object.`);
+  }
+  return Object.freeze(value);
+}
+function parsePresenceHashMembers(values) {
+  const members = /* @__PURE__ */ new Map();
+  for (const [socketRef, encoded] of Object.entries(values)) {
+    try {
+      const parsed = parseJsonObject(encoded, `Presence member "${socketRef}"`);
+      members.set(socketRef, Object.freeze(parsed));
+    } catch {
+      members.set(socketRef, Object.freeze({ id: socketRef }));
+    }
+  }
+  return members;
+}
+function resolveRedisScalingConnection(queueConfig, connectionName, redisConfig) {
+  const queueConnection = queueConfig?.connections[connectionName];
+  if (queueConnection?.driver === "redis") {
+    return Object.freeze({
+      ...typeof queueConnection.redis.url === "undefined" ? {} : { url: queueConnection.redis.url },
+      ...typeof queueConnection.redis.clusters === "undefined" ? {} : { clusters: queueConnection.redis.clusters },
+      host: queueConnection.redis.host,
+      port: queueConnection.redis.port,
+      username: queueConnection.redis.username,
+      password: queueConnection.redis.password,
+      db: queueConnection.redis.db
+    });
+  }
+  const redisConnection = redisConfig?.connections[connectionName];
+  if (redisConnection) {
+    return Object.freeze({
+      ...typeof redisConnection.url === "undefined" ? {} : { url: redisConnection.url },
+      ...typeof redisConnection.clusters === "undefined" ? {} : { clusters: redisConnection.clusters },
+      host: redisConnection.host,
+      port: redisConnection.port,
+      username: redisConnection.username,
+      password: redisConnection.password,
+      db: redisConnection.db
+    });
+  }
+  if (queueConnection) {
+    throw new Error(
+      `[@holo-js/broadcast] Broadcast scaling connection "${connectionName}" must use the Redis queue driver.`
+    );
+  }
+  if (redisConfig && typeof redisConfig.connections === "object") {
+    const availableConnections = Object.keys(redisConfig.connections);
+    throw new Error(
+      `[@holo-js/broadcast] Broadcast scaling connection "${connectionName}" was not found in top-level redis connections. Available redis connections: ${availableConnections.join(", ") || "(none)"}.`
+    );
+  }
+  if (!queueConfig) {
+    throw new Error("[@holo-js/broadcast] Broadcast scaling requires either redis config or a Redis queue connection so the Redis connection can be resolved.");
+  }
+  throw new Error(`[@holo-js/broadcast] Broadcast scaling connection "${connectionName}" was not found in queue connections.`);
+}
+function resolveScalingConnectionName(connectionName, queueConfig, redisConfig) {
+  const queueDefaultConnection = queueConfig ? queueConfig.connections[queueConfig.default] : void 0;
+  if (connectionName !== "default") {
+    return connectionName;
+  }
+  if (queueDefaultConnection?.driver === "redis") {
+    return queueConfig.default;
+  }
+  return redisConfig?.default ?? connectionName;
+}
+function isRedisSocketConnectionTarget(value) {
+  return value.startsWith("unix://") || value.startsWith("/");
+}
+function toRedisSocketPath(value) {
+  return value.startsWith("unix://") ? value.slice("unix://".length) : value;
+}
+function parseRedisClusterNodeUrl(url, label) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+      throw new Error(`unsupported protocol "${parsed.protocol}"`);
+    }
+    if (!parsed.hostname) {
+      throw new Error("missing hostname");
+    }
+    return {
+      host: parsed.hostname,
+      port: parsed.port ? Number.parseInt(parsed.port, 10) : 6379,
+      ...parsed.protocol === "rediss:" ? { tls: {} } : {}
+    };
+  } catch (error) {
+    throw new Error(`[@holo-js/broadcast] ${label} is invalid: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function resolveRedisClusterStartupNodes(clusters) {
+  return clusters.map((node, index) => {
+    const label = `Broadcast scaling cluster node ${index + 1}`;
+    if (typeof node.url === "string") {
+      return parseRedisClusterNodeUrl(node.url, `${label} url`);
+    }
+    if (isRedisSocketConnectionTarget(node.host)) {
+      throw new Error(`[@holo-js/broadcast] ${label} cannot use a Unix socket path in Redis cluster mode.`);
+    }
+    return {
+      host: node.host,
+      port: node.port
+    };
+  });
+}
+async function loadRedisScalingModule(loadModule) {
+  try {
+    const loadDefaultModule = async () => {
+      const specifier = "ioredis";
+      return await import(
+        /* webpackIgnore: true */
+        specifier
+      );
+    };
+    const loaded = await (loadModule ? loadModule() : loadDefaultModule());
+    if (!loaded || typeof loaded !== "object" || typeof loaded.default !== "function") {
+      throw new Error("missing default Redis export");
+    }
+    return loaded;
+  } catch (error) {
+    const code = error && typeof error === "object" ? error.code : void 0;
+    const message = error instanceof Error ? error.message : String(error);
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || /Cannot find module|Failed to resolve module/i.test(message)) {
+      throw new Error(
+        '[@holo-js/broadcast] Redis scaling requires the "ioredis" package. Install it in your project dependencies to enable worker scaling.'
+      );
+    }
+    throw error;
+  }
+}
+async function createRedisScalingAdapter(connection, dependencies = {}) {
+  if (connection.clusters && connection.clusters.length > 0 && connection.db !== 0) {
+    throw new Error("[@holo-js/broadcast] Redis Cluster does not support selecting a non-zero database. Remove redis.db or set it to 0.");
+  }
+  const redisModule = await loadRedisScalingModule(dependencies.loadRedisModule);
+  const RedisCtor = redisModule.default;
+  const createClient = () => {
+    if (connection.clusters && connection.clusters.length > 0) {
+      const startupNodes = resolveRedisClusterStartupNodes(connection.clusters);
+      return new redisModule.Cluster(
+        startupNodes,
+        {
+          redisOptions: {
+            username: connection.username,
+            password: connection.password,
+            db: connection.db,
+            ...startupNodes.some((node) => typeof node.tls !== "undefined") ? { tls: {} } : {}
+          }
+        }
+      );
+    }
+    if (typeof connection.url === "string") {
+      return new RedisCtor(connection.url, {
+        username: connection.username,
+        password: connection.password,
+        db: connection.db
+      });
+    }
+    return new RedisCtor(
+      isRedisSocketConnectionTarget(connection.host) ? {
+        path: toRedisSocketPath(connection.host),
+        username: connection.username,
+        password: connection.password,
+        db: connection.db
+      } : {
+        host: connection.host,
+        port: connection.port,
+        username: connection.username,
+        password: connection.password,
+        db: connection.db
+      }
+    );
+  };
+  const commandClient = createClient();
+  const subscriberClient = createClient();
+  const listeners = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    async publish(channel2, payload) {
+      await commandClient.publish(channel2, payload);
+    },
+    async subscribe(channel2, onMessage) {
+      const listener = (incomingChannel, payload) => {
+        if (incomingChannel === channel2) {
+          onMessage(payload);
+        }
+      };
+      listeners.set(channel2, listener);
+      subscriberClient.on("message", listener);
+      await subscriberClient.subscribe(channel2);
+      return async () => {
+        const existing = listeners.get(channel2);
+        if (existing) {
+          await subscriberClient.unsubscribe(channel2);
+          subscriberClient.off("message", existing);
+          listeners.delete(channel2);
+        }
+      };
+    },
+    async hashSet(key, field, value) {
+      await commandClient.hset(key, field, value);
+    },
+    async hashDelete(key, field) {
+      await commandClient.hdel(key, field);
+    },
+    async hashGetAll(key) {
+      return Object.freeze(await commandClient.hgetall(key));
+    },
+    async close() {
+      try {
+        await subscriberClient.quit();
+      } catch {
+        subscriberClient.disconnect();
+      }
+      try {
+        await commandClient.quit();
+      } catch {
+        commandClient.disconnect();
+      }
+    }
+  });
+}
+function buildWorkerApps(config) {
+  const appsByKey = /* @__PURE__ */ new Map();
+  for (const [name, connection] of Object.entries(config.connections)) {
+    if (connection.driver !== "holo" || !("key" in connection) || !("secret" in connection) || !("appId" in connection)) {
+      continue;
+    }
+    const holoConnection = connection;
+    const authEndpoint = typeof holoConnection.clientOptions.authEndpoint === "string" ? normalizeRequiredString(holoConnection.clientOptions.authEndpoint, `Broadcast connection "${name}" authEndpoint`) : void 0;
+    if (appsByKey.has(holoConnection.key)) {
+      throw new Error(`[@holo-js/broadcast] duplicate broadcast app key "${holoConnection.key}" is already configured.`);
+    }
+    appsByKey.set(holoConnection.key, Object.freeze({
+      connection: name,
+      appId: holoConnection.appId,
+      key: holoConnection.key,
+      secret: holoConnection.secret,
+      ...typeof authEndpoint === "undefined" ? {} : { authEndpoint }
+    }));
+  }
+  if (appsByKey.size === 0) {
+    throw new Error('[@holo-js/broadcast] Broadcast worker requires at least one "holo" broadcast connection.');
+  }
+  return Object.freeze(Object.fromEntries(appsByKey));
+}
+function pusherEvent(event, data, channel2) {
+  return JSON.stringify({
+    event,
+    ...typeof channel2 === "undefined" ? {} : { channel: channel2 },
+    data: typeof data === "string" ? data : JSON.stringify(data)
+  });
+}
+async function authenticateSubscription(app, connection, channel2, channelAuth, fetcher) {
+  const { kind, canonical } = parseChannelKind(channel2);
+  if (kind === "public") {
+    return Object.freeze({
+      whispers: Object.freeze([])
+    });
+  }
+  if (app.authEndpoint && fetcher) {
+    const authRequest = new Request(app.authEndpoint, {
+      method: "POST",
+      headers: Object.fromEntries(
+        [...connection.headers.entries()].filter(([header]) => {
+          const normalized = header.toLowerCase();
+          return normalized === "authorization" || normalized === "cookie";
+        })
+      ),
+      body: new URLSearchParams({
+        channel_name: canonical,
+        socket_id: connection.socketId
+      })
+    });
+    const response = await fetcher(authRequest);
+    if (!response.ok) {
+      throw new Error(`[@holo-js/broadcast] Channel authorization rejected (${response.status}).`);
+    }
+    const body = await response.json();
+    const whispers = Array.isArray(body.whispers) ? Object.freeze(body.whispers.map((value) => normalizeRequiredString(String(value), "Auth whisper"))) : Object.freeze([]);
+    const member = body.member && typeof body.member === "object" && !Array.isArray(body.member) ? Object.freeze(body.member) : void 0;
+    return Object.freeze({
+      whispers,
+      ...typeof member === "undefined" ? {} : { member }
+    });
+  }
+  const resolvedUser = typeof channelAuth?.resolveUser === "function" ? await channelAuth.resolveUser({
+    headers: connection.headers,
+    socketId: connection.socketId,
+    channel: canonical,
+    appId: app.appId,
+    connection: app.connection
+  }) : null;
+  const authorized = await authorizeBroadcastChannel({
+    channel: canonical,
+    socketId: connection.socketId,
+    user: resolvedUser ?? null
+  }, channelAuth);
+  if (!authorized.ok) {
+    throw new Error(`[@holo-js/broadcast] Channel authorization denied for "${channel2}".`);
+  }
+  return Object.freeze({
+    whispers: authorized.whispers,
+    /* v8 ignore next -- exercised in integration tests for private and presence channel auth; expression is kept for TS narrowing. */
+    ...authorized.type === "presence" ? { member: authorized.member } : {}
+  });
+}
+function createBroadcastWorkerRuntime(options) {
+  const appsByKey = buildWorkerApps(options.config);
+  const connectedSockets = /* @__PURE__ */ new Map();
+  const channels = /* @__PURE__ */ new Map();
+  const channelWhispers = /* @__PURE__ */ new Map();
+  const presenceMembers = /* @__PURE__ */ new Map();
+  const presenceSockets = /* @__PURE__ */ new Map();
+  const scaling = options.scaling;
+  const startedAt = options.now?.() ?? Date.now();
+  const scalingUnsubscribe = options.scalingUnsubscribe ? Promise.resolve(options.scalingUnsubscribe) : scaling && options.scalingAutoSubscribe !== false ? scaling.adapter.subscribe(scaling.eventChannel, (payload) => {
+    void handleScalingMessage(payload).catch((error) => {
+      logScalingMessageError(error);
+    });
+  }) : Promise.resolve(async () => {
+  });
+  function createPresenceSocketRef(channel2, socketId) {
+    return scaling && parseChannelKind(channel2).kind === "presence" ? createNodeSocketRef(scaling.nodeId, socketId) : socketId;
+  }
+  function setPresenceState(key, socketMembers) {
+    if (socketMembers.size === 0) {
+      presenceMembers.delete(key);
+      presenceSockets.delete(key);
+      return /* @__PURE__ */ new Map();
+    }
+    const roster = /* @__PURE__ */ new Map();
+    const memberSockets = /* @__PURE__ */ new Map();
+    for (const [socketRef, member] of socketMembers) {
+      const memberId = resolvePresenceMemberId(member, socketRef);
+      memberSockets.set(socketRef, memberId);
+      if (!roster.has(memberId)) {
+        roster.set(memberId, member);
+      }
+    }
+    presenceMembers.set(key, roster);
+    presenceSockets.set(key, memberSockets);
+    return roster;
+  }
+  function getPresenceRosterPayload(key) {
+    const roster = presenceMembers.get(key) ?? /* @__PURE__ */ new Map();
+    const ids = Object.freeze([...roster.keys()]);
+    return Object.freeze({
+      ids,
+      hash: Object.freeze(Object.fromEntries(roster.entries())),
+      count: ids.length
+    });
+  }
+  async function removePresenceMemberFromScaling(app, socketId, channel2) {
+    if (!scaling) {
+      return;
+    }
+    const { kind } = parseChannelKind(channel2);
+    if (kind !== "presence") {
+      return;
+    }
+    await scaling.adapter.hashDelete(
+      resolvePresenceHashKey(scaling.connection, app.appId, channel2),
+      createNodeSocketRef(scaling.nodeId, socketId)
+    );
+  }
+  function removeSubscriptionLocal(appId, socketId, channel2) {
+    const key = composeSubscriptionKey(appId, channel2);
+    const sockets = channels.get(key);
+    if (sockets) {
+      sockets.delete(socketId);
+      if (sockets.size === 0) {
+        channels.delete(key);
+      }
+    }
+    let removedPresenceMember;
+    let removed = false;
+    const roster = presenceMembers.get(key);
+    const memberSockets = presenceSockets.get(key);
+    if (roster && memberSockets) {
+      const presenceSocketRef = createPresenceSocketRef(channel2, socketId);
+      const memberId = memberSockets.get(presenceSocketRef);
+      if (memberId) {
+        memberSockets.delete(presenceSocketRef);
+        if (memberSockets.size === 0) {
+          presenceSockets.delete(key);
+        }
+        if (![...memberSockets.values()].includes(memberId)) {
+          removedPresenceMember = roster.get(memberId);
+          removed = typeof removedPresenceMember !== "undefined";
+          roster.delete(memberId);
+          if (roster.size === 0) {
+            presenceMembers.delete(key);
+          }
+        }
+      }
+    }
+    const whispersBySocket = channelWhispers.get(key);
+    if (whispersBySocket) {
+      whispersBySocket.delete(socketId);
+      if (whispersBySocket.size === 0) {
+        channelWhispers.delete(key);
+      }
+    }
+    return Object.freeze({
+      ...typeof removedPresenceMember === "undefined" ? {} : { member: removedPresenceMember },
+      removed
+    });
+  }
+  async function synchronizePresenceChannel(app, channel2, member, socketId) {
+    const key = composeSubscriptionKey(app.appId, channel2);
+    const socketRef = createPresenceSocketRef(channel2, socketId);
+    const memberId = resolvePresenceMemberId(member, socketRef);
+    if (!scaling) {
+      const roster2 = presenceMembers.get(key) ?? /* @__PURE__ */ new Map();
+      const memberSockets = presenceSockets.get(key) ?? /* @__PURE__ */ new Map();
+      const isNewMember = !roster2.has(memberId);
+      memberSockets.set(socketRef, memberId);
+      roster2.set(memberId, member);
+      presenceSockets.set(key, memberSockets);
+      presenceMembers.set(key, roster2);
+      return Object.freeze({
+        roster: roster2,
+        isNewMember
+      });
+    }
+    const presenceKey = resolvePresenceHashKey(scaling.connection, app.appId, channel2);
+    await scaling.adapter.hashSet(
+      presenceKey,
+      socketRef,
+      JSON.stringify(member)
+    );
+    const merged = parsePresenceHashMembers(await scaling.adapter.hashGetAll(presenceKey));
+    const hasExistingMember = [...merged.entries()].some(([existingSocketRef, existingMember]) => {
+      return existingSocketRef !== socketRef && resolvePresenceMemberId(existingMember, existingSocketRef) === memberId;
+    });
+    const roster = setPresenceState(key, merged);
+    return Object.freeze({
+      roster,
+      isNewMember: !hasExistingMember
+    });
+  }
+  function deliverEventLocal(appId, channel2, event, data, excludeSocketId) {
+    const sockets = channels.get(composeSubscriptionKey(appId, channel2));
+    if (!sockets || sockets.size === 0) {
+      return Object.freeze({
+        deliveredChannels: Object.freeze([]),
+        deliveredSockets: 0
+      });
+    }
+    let deliveredSockets = 0;
+    for (const socketId of sockets) {
+      if (socketId === excludeSocketId) {
+        continue;
+      }
+      const socket = connectedSockets.get(socketId);
+      if (!socket) {
+        continue;
+      }
+      socket.send(pusherEvent(event, data, channel2));
+      deliveredSockets += 1;
+    }
+    return Object.freeze({
+      deliveredChannels: Object.freeze([channel2]),
+      deliveredSockets
+    });
+  }
+  function deliverPresenceMemberAddedLocal(appId, channel2, member, excludeSocketId) {
+    deliverEventLocal(
+      appId,
+      channel2,
+      "pusher_internal:member_added",
+      JSON.stringify(member),
+      excludeSocketId
+    );
+  }
+  function deliverPresenceMemberRemovedLocal(appId, channel2, member, excludeSocketId, fallbackSocketId) {
+    deliverEventLocal(
+      appId,
+      channel2,
+      "pusher_internal:member_removed",
+      serializePresenceMemberRemoved(member, fallbackSocketId ?? excludeSocketId),
+      excludeSocketId
+    );
+  }
+  async function publishScalingEvent(body) {
+    if (!scaling) {
+      return;
+    }
+    await scaling.adapter.publish(scaling.eventChannel, JSON.stringify({
+      type: "event",
+      originNodeId: scaling.nodeId,
+      appId: body.appId,
+      name: body.name,
+      channels: body.channels,
+      data: body.data,
+      ...typeof body.socket_id === "undefined" ? {} : { socketId: body.socket_id }
+    }));
+  }
+  async function publishScalingPresenceMemberAdded(app, channel2, socketId, member) {
+    if (!scaling) {
+      return;
+    }
+    await scaling.adapter.publish(scaling.eventChannel, JSON.stringify({
+      type: "presence-member-added",
+      originNodeId: scaling.nodeId,
+      appId: app.appId,
+      channel: channel2,
+      socketId,
+      member
+    }));
+  }
+  async function publishScalingPresenceMemberRemoved(app, channel2, socketId, member) {
+    if (!scaling) {
+      return;
+    }
+    await scaling.adapter.publish(scaling.eventChannel, JSON.stringify({
+      type: "presence-member-removed",
+      originNodeId: scaling.nodeId,
+      appId: app.appId,
+      channel: channel2,
+      socketId,
+      member
+    }));
+  }
+  async function handleScalingMessage(payload) {
+    const message = parseJsonObject(payload, "Scaling event payload");
+    if (message.originNodeId === scaling?.nodeId) {
+      return;
+    }
+    if (message.type === "event") {
+      if (typeof message.name !== "string" || !Array.isArray(message.channels) || typeof message.data !== "string" || typeof message.appId !== "string") {
+        return;
+      }
+      const socketId = typeof message.socketId === "string" ? message.socketId : typeof message.socket_id === "string" ? message.socket_id : void 0;
+      for (const channel2 of message.channels) {
+        if (typeof channel2 !== "string") {
+          continue;
+        }
+        deliverEventLocal(
+          message.appId,
+          channel2,
+          message.name,
+          message.data,
+          socketId
+        );
+      }
+      return;
+    }
+    if (message.type === "presence-member-added" && typeof message.originNodeId === "string" && typeof message.appId === "string" && typeof message.channel === "string" && typeof message.socketId === "string") {
+      const key = composeSubscriptionKey(message.appId, message.channel);
+      const roster = presenceMembers.get(key) ?? /* @__PURE__ */ new Map();
+      const memberSockets = presenceSockets.get(key) ?? /* @__PURE__ */ new Map();
+      const member = normalizePresenceMemberMessage(message.member, "Scaling presence member");
+      const socketRef = createNodeSocketRef(message.originNodeId, message.socketId);
+      const memberId = resolvePresenceMemberId(member, socketRef);
+      const isNewMember = !roster.has(memberId);
+      memberSockets.set(socketRef, memberId);
+      roster.set(memberId, member);
+      presenceSockets.set(key, memberSockets);
+      presenceMembers.set(key, roster);
+      if (isNewMember) {
+        deliverPresenceMemberAddedLocal(message.appId, message.channel, member);
+      }
+      return;
+    }
+    if (message.type === "presence-member-removed" && typeof message.originNodeId === "string" && typeof message.appId === "string" && typeof message.channel === "string" && typeof message.socketId === "string") {
+      const member = normalizePresenceMemberMessage(message.member, "Scaling presence member");
+      const key = composeSubscriptionKey(message.appId, message.channel);
+      const roster = presenceMembers.get(key);
+      const memberSockets = presenceSockets.get(key);
+      const socketRef = createNodeSocketRef(message.originNodeId, message.socketId);
+      const memberId = memberSockets?.get(socketRef) ?? resolvePresenceMemberId(member, socketRef);
+      if (memberSockets) {
+        memberSockets.delete(socketRef);
+        if (memberSockets.size === 0) {
+          presenceSockets.delete(key);
+        }
+      }
+      if (roster && !memberSockets?.has(socketRef)) {
+        if (!(memberSockets && [...memberSockets.values()].includes(memberId))) {
+          roster.delete(memberId);
+          if (roster.size === 0) {
+            presenceMembers.delete(key);
+          }
+          deliverPresenceMemberRemovedLocal(
+            message.appId,
+            message.channel,
+            member,
+            void 0,
+            memberId
+          );
+        }
+      }
+    }
+  }
+  async function handleSubscribe(socket, rawChannel) {
+    const channel2 = normalizeRequiredString(rawChannel, "Subscription channel");
+    const authorization = await authenticateSubscription(socket.app, socket, channel2, options.channelAuth, options.fetch);
+    if (!socket.active || connectedSockets.get(socket.socketId) !== socket) {
+      return;
+    }
+    socket.subscribedChannels.add(channel2);
+    const key = composeSubscriptionKey(socket.app.appId, channel2);
+    channels.set(key, /* @__PURE__ */ new Set([...channels.get(key) ?? [], socket.socketId]));
+    if (authorization.whispers.length > 0) {
+      const whispersBySocket = channelWhispers.get(key) ?? /* @__PURE__ */ new Map();
+      whispersBySocket.set(socket.socketId, new Set(authorization.whispers));
+      channelWhispers.set(key, whispersBySocket);
+    } else {
+      const whispersBySocket = channelWhispers.get(key);
+      whispersBySocket?.delete(socket.socketId);
+      if (whispersBySocket && whispersBySocket.size === 0) {
+        channelWhispers.delete(key);
+      }
+    }
+    const { kind } = parseChannelKind(channel2);
+    if (kind === "presence") {
+      const member = authorization.member ?? Object.freeze({ id: socket.socketId });
+      const synchronized = await synchronizePresenceChannel(
+        socket.app,
+        channel2,
+        member,
+        socket.socketId
+      );
+      if (synchronized.isNewMember) {
+        deliverPresenceMemberAddedLocal(socket.app.appId, channel2, member, socket.socketId);
+        await publishScalingPresenceMemberAdded(socket.app, channel2, socket.socketId, member);
+      }
+      const presence = getPresenceRosterPayload(key);
+      socket.send(pusherEvent("pusher_internal:subscription_succeeded", {
+        presence
+      }, channel2));
+      return;
+    }
+    socket.send(pusherEvent("pusher_internal:subscription_succeeded", {}, channel2));
+  }
+  async function handleUnsubscribe(socket, rawChannel) {
+    const channel2 = normalizeRequiredString(rawChannel, "Unsubscribe channel");
+    socket.subscribedChannels.delete(channel2);
+    const removedPresenceMember = removeSubscriptionLocal(socket.app.appId, socket.socketId, channel2);
+    if (removedPresenceMember.removed && removedPresenceMember.member) {
+      deliverPresenceMemberRemovedLocal(socket.app.appId, channel2, removedPresenceMember.member, socket.socketId);
+    }
+    await removePresenceMemberFromScaling(socket.app, socket.socketId, channel2);
+    if (removedPresenceMember.removed && removedPresenceMember.member) {
+      await publishScalingPresenceMemberRemoved(socket.app, channel2, socket.socketId, removedPresenceMember.member);
+    }
+    socket.send(pusherEvent("pusher_internal:unsubscribed", {}, channel2));
+  }
+  async function handleClientEvent(socket, message) {
+    const channel2 = normalizeRequiredString(message.channel ?? "", "Whisper channel");
+    if (!socket.subscribedChannels.has(channel2)) {
+      throw new Error(`[@holo-js/broadcast] Socket is not subscribed to "${channel2}".`);
+    }
+    const { kind, canonical } = parseChannelKind(channel2);
+    if (kind === "public") {
+      throw new Error("[@holo-js/broadcast] Client events are only allowed on private or presence channels.");
+    }
+    const whisperName = message.event.replace(/^client-/, "");
+    const allowedWhispers = channelWhispers.get(composeSubscriptionKey(socket.app.appId, channel2))?.get(socket.socketId);
+    if (!allowedWhispers || !allowedWhispers.has(whisperName)) {
+      throw new Error(`[@holo-js/broadcast] Whisper "${whisperName}" is not allowed for "${channel2}".`);
+    }
+    if (options.channelAuth) {
+      await validateBroadcastWhisperPayload(canonical, whisperName, message.data, options.channelAuth);
+    }
+    const payload = Object.freeze({
+      name: message.event,
+      channels: Object.freeze([channel2]),
+      data: JSON.stringify(message.data),
+      appId: socket.app.appId,
+      socket_id: socket.socketId
+    });
+    await publishToChannels(payload, {
+      fromScaling: false,
+      shouldReplicate: true
+    });
+  }
+  async function publishToChannels(body, options2 = {
+    fromScaling: false,
+    shouldReplicate: true
+  }) {
+    let deliveredSockets = 0;
+    const deliveredChannels = [];
+    for (const channel2 of body.channels) {
+      const result = deliverEventLocal(body.appId, channel2, body.name, body.data, body.socket_id);
+      if (result.deliveredSockets > 0) {
+        deliveredChannels.push(channel2);
+      }
+      deliveredSockets += result.deliveredSockets;
+    }
+    if (!options2.fromScaling && options2.shouldReplicate) {
+      await publishScalingEvent(body);
+    }
+    return Object.freeze({
+      deliveredChannels: Object.freeze(deliveredChannels),
+      deliveredSockets
+    });
+  }
+  async function handlePublishRequest(request) {
+    const url = new URL(request.url);
+    const match = url.pathname.match(/\/apps\/([^/]+)\/events$/);
+    const appId = normalizeRequiredString(match?.[1] ?? "", "Publish appId");
+    const app = Object.values(appsByKey).find((candidate) => candidate.appId === appId);
+    if (!app) {
+      return new Response("App not found", { status: 404 });
+    }
+    const bodyText = await request.text();
+    const bodyMd5 = createHash("md5").update(bodyText).digest("hex");
+    if (url.searchParams.get("body_md5") !== bodyMd5) {
+      return new Response("Invalid body signature", { status: 401 });
+    }
+    let authKey;
+    try {
+      authKey = normalizeRequiredString(url.searchParams.get("auth_key") ?? "", "Publish auth_key");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Invalid credentials";
+      return new Response(message, { status: 401 });
+    }
+    if (authKey !== app.key) {
+      return new Response("Invalid credentials", { status: 401 });
+    }
+    let authTimestamp;
+    try {
+      authTimestamp = Number.parseInt(
+        normalizeRequiredString(url.searchParams.get("auth_timestamp") ?? "", "Publish auth_timestamp"),
+        10
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Invalid auth timestamp";
+      return new Response(message, { status: 401 });
+    }
+    if (!Number.isInteger(authTimestamp)) {
+      return new Response("Invalid auth timestamp", { status: 401 });
+    }
+    const nowSeconds = Math.floor((options.now?.() ?? Date.now()) / 1e3);
+    if (Math.abs(nowSeconds - authTimestamp) > MAX_PUBLISH_TIMESTAMP_SKEW_SECONDS) {
+      return new Response("Publish auth timestamp is stale", { status: 401 });
+    }
+    let providedSignature;
+    let expectedSignature;
+    try {
+      providedSignature = normalizeRequiredString(url.searchParams.get("auth_signature") ?? "", "Publish auth_signature");
+      expectedSignature = createPusherSignature(
+        app.secret,
+        request.method,
+        url.pathname,
+        url.searchParams
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Invalid auth signature";
+      return new Response(message, { status: 401 });
+    }
+    if (providedSignature !== expectedSignature) {
+      return new Response("Invalid auth signature", { status: 401 });
+    }
+    let publishBody;
+    try {
+      publishBody = normalizePublishBody(parseJsonObject(bodyText, "Publish body"));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Invalid publish payload";
+      return new Response(message, { status: 400 });
+    }
+    let result;
+    try {
+      result = await publishToChannels({
+        ...publishBody,
+        appId: app.appId
+      }, {
+        fromScaling: false,
+        shouldReplicate: true
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Broadcast publish failed.";
+      return new Response(message, { status: 500 });
+    }
+    return new Response(JSON.stringify({
+      ok: true,
+      deliveredChannels: result.deliveredChannels,
+      deliveredSockets: result.deliveredSockets
+    }), {
+      status: 200,
+      headers: {
+        "content-type": "application/json; charset=utf-8"
+      }
+    });
+  }
+  return Object.freeze({
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (request.method.toUpperCase() === "GET" && url.pathname === options.config.worker.healthPath) {
+        return new Response(JSON.stringify({
+          ok: true
+        }), {
+          headers: {
+            "content-type": "application/json; charset=utf-8"
+          }
+        });
+      }
+      if (request.method.toUpperCase() === "GET" && url.pathname === options.config.worker.statsPath) {
+        return new Response(JSON.stringify({
+          ...this.getStats()
+        }), {
+          headers: {
+            "content-type": "application/json; charset=utf-8"
+          }
+        });
+      }
+      if (request.method.toUpperCase() === "POST" && /\/apps\/[^/]+\/events$/.test(url.pathname)) {
+        return await handlePublishRequest(request);
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+    connectWebSocket(connection) {
+      connectedSockets.set(connection.socketId, {
+        socketId: connection.socketId,
+        app: connection.app,
+        headers: connection.headers,
+        send: connection.send,
+        close: connection.close,
+        subscribedChannels: /* @__PURE__ */ new Set(),
+        active: true,
+        pendingMessage: Promise.resolve()
+      });
+      connection.send(pusherEvent("pusher:connection_established", {
+        socket_id: connection.socketId,
+        activity_timeout: 120
+      }));
+    },
+    async receiveWebSocketMessage(socketId, rawMessage) {
+      const socket = connectedSockets.get(socketId);
+      if (!socket) {
+        return;
+      }
+      const task = socket.pendingMessage.then(async () => {
+        if (!socket.active || connectedSockets.get(socketId) !== socket) {
+          return;
+        }
+        const message = parseSocketMessage(rawMessage);
+        if (message.event === "pusher:ping") {
+          socket.send(pusherEvent("pusher:pong", {}));
+          return;
+        }
+        if (message.event === "pusher:subscribe") {
+          await handleSubscribe(socket, String(message.data.channel ?? ""));
+          return;
+        }
+        if (message.event === "pusher:unsubscribe") {
+          await handleUnsubscribe(socket, String(message.data.channel ?? ""));
+          return;
+        }
+        if (message.event.startsWith("client-")) {
+          await handleClientEvent(socket, message);
+        }
+      });
+      socket.pendingMessage = task.catch(() => {
+      });
+      await task;
+    },
+    async receiveScalingMessage(payload) {
+      await handleScalingMessage(payload);
+    },
+    disconnectWebSocket(socketId) {
+      const socket = connectedSockets.get(socketId);
+      if (!socket) {
+        return;
+      }
+      socket.active = false;
+      connectedSockets.delete(socketId);
+      const channelsToCleanup = [...socket.subscribedChannels];
+      const scalingCleanupTasks = channelsToCleanup.map((channel2) => {
+        const removedPresenceMember = removeSubscriptionLocal(socket.app.appId, socket.socketId, channel2);
+        if (removedPresenceMember.removed && removedPresenceMember.member) {
+          deliverPresenceMemberRemovedLocal(socket.app.appId, channel2, removedPresenceMember.member, socket.socketId);
+        }
+        return async () => {
+          if (removedPresenceMember.removed && removedPresenceMember.member) {
+            await publishScalingPresenceMemberRemoved(socket.app, channel2, socket.socketId, removedPresenceMember.member).catch((error) => {
+              logSocketCleanupError(socket.socketId, channel2, error);
+            });
+          }
+          await removePresenceMemberFromScaling(socket.app, socket.socketId, channel2).catch((error) => {
+            logSocketCleanupError(socket.socketId, channel2, error);
+          });
+        };
+      });
+      socket.subscribedChannels.clear();
+      const cleanupTask = socket.pendingMessage.then(async () => {
+        await Promise.all(scalingCleanupTasks.map(async (task) => {
+          await task();
+        }));
+      }).catch((error) => {
+        logSocketMessageError(socket.socketId, error);
+      });
+      socket.pendingMessage = cleanupTask.catch(() => {
+      });
+    },
+    getStats() {
+      return Object.freeze({
+        nodeId: scaling?.nodeId ?? "standalone",
+        uptimeMs: (options.now?.() ?? Date.now()) - startedAt,
+        apps: Object.freeze(Object.values(appsByKey).map((app) => app.connection)),
+        appScopes: Object.freeze(Object.values(appsByKey).map((app) => Object.freeze({
+          connection: app.connection,
+          appId: app.appId,
+          key: app.key
+        }))),
+        connectionCount: connectedSockets.size,
+        subscribedChannelCount: channels.size,
+        presenceChannelCount: presenceMembers.size,
+        scaling: scaling ? Object.freeze({
+          driver: "redis",
+          connection: scaling.connection,
+          eventChannel: scaling.eventChannel
+        }) : false
+      });
+    },
+    async close() {
+      const unsubscribe = await scalingUnsubscribe;
+      await unsubscribe();
+      if (scaling) {
+        await scaling.adapter.close();
+      }
+    }
+  });
+}
+function toNodeHeaders(headers) {
+  const normalized = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "undefined") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        normalized.append(key, item);
+      }
+      continue;
+    }
+    normalized.set(key, value);
+  }
+  return normalized;
+}
+function toNodeRequestUrl(request, fallbackHost) {
+  const path = request.url ?? "/";
+  const host = request.headers.host ?? fallbackHost;
+  return `http://${host}${path}`;
+}
+async function readNodeRequestBody(request) {
+  if (request.method === "GET" || request.method === "HEAD") {
+    return void 0;
+  }
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  return Buffer.concat(chunks);
+}
+async function writeNodeResponse(response, value) {
+  response.statusCode = value.status;
+  response.statusMessage = value.statusText;
+  value.headers.forEach((headerValue, headerName) => {
+    response.setHeader(headerName, headerValue);
+  });
+  const body = await value.arrayBuffer();
+  response.end(Buffer.from(body));
+}
+function decodeNodeWebSocketMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof ArrayBuffer) {
+    return new TextDecoder().decode(new Uint8Array(message));
+  }
+  if (Array.isArray(message)) {
+    return Buffer.concat(message).toString("utf8");
+  }
+  if (message instanceof Uint8Array) {
+    return Buffer.from(message).toString("utf8");
+  }
+  return String(message);
+}
+async function handleSubscribeFailure(runtime, subscribeError) {
+  try {
+    await runtime.close();
+  } catch {
+  }
+  throw subscribeError;
+}
+async function startBroadcastWorker(runtimeBindings) {
+  const config = runtimeBindings.config;
+  if (!config) {
+    throw new Error("[@holo-js/broadcast] Broadcast worker requires a loaded broadcast config.");
+  }
+  const scalingConnectionName = config.worker.scaling ? resolveScalingConnectionName(config.worker.scaling.connection, runtimeBindings.queue, runtimeBindings.redis) : void 0;
+  const scalingConfig = config.worker.scaling ? Object.freeze({
+    driver: "redis",
+    connection: scalingConnectionName,
+    nodeId: runtimeBindings.nodeId ?? createScalingNodeId(),
+    eventChannel: resolveScalingEventChannel(scalingConnectionName),
+    adapter: await (runtimeBindings.createScalingAdapter ? runtimeBindings.createScalingAdapter(
+      resolveRedisScalingConnection(runtimeBindings.queue, scalingConnectionName, runtimeBindings.redis)
+    ) : createRedisScalingAdapter(
+      resolveRedisScalingConnection(runtimeBindings.queue, scalingConnectionName, runtimeBindings.redis),
+      { loadRedisModule: runtimeBindings.loadRedisModule }
+    ))
+  }) : void 0;
+  let scalingUnsubscribe;
+  const runtime = createBroadcastWorkerRuntime({
+    config,
+    channelAuth: runtimeBindings.channelAuth,
+    fetch: runtimeBindings.fetch ?? fetch,
+    scaling: scalingConfig,
+    scalingAutoSubscribe: false,
+    scalingUnsubscribe: async () => {
+      await scalingUnsubscribe?.();
+    }
+  });
+  if (scalingConfig) {
+    scalingUnsubscribe = await scalingConfig.adapter.subscribe(scalingConfig.eventChannel, (payload) => {
+      void runtime.receiveScalingMessage(payload).catch((error) => {
+        logScalingMessageError(error);
+      });
+    }).catch((subscribeError) => handleSubscribeFailure(runtime, subscribeError));
+  }
+  const bun = globalThis.Bun;
+  const appsByKey = buildWorkerApps(config);
+  const pathPrefix = config.worker.path.replace(/\/$/, "");
+  const appPathRegex = new RegExp(`^${escapeRegExp(pathPrefix)}/([^/]+)$`);
+  if (bun?.serve) {
+    const server = bun.serve({
+      hostname: config.worker.host,
+      port: config.worker.port,
+      async fetch(request, wsServer2) {
+        const url = new URL(request.url);
+        const appMatch = url.pathname.match(appPathRegex);
+        if (appMatch) {
+          const key = appMatch[1];
+          const app = appsByKey[key];
+          if (!app) {
+            return new Response("Unknown app key", { status: 401 });
+          }
+          const upgraded = wsServer2.upgrade(request, {
+            data: {
+              socketId: createSocketId(),
+              app,
+              headers: request.headers
+            }
+          });
+          if (upgraded) {
+            return new Response(null, { status: 200 });
+          }
+        }
+        return await runtime.fetch(request);
+      },
+      websocket: {
+        open(socket) {
+          runtime.connectWebSocket({
+            ...socket.data,
+            send(payload) {
+              socket.send(payload);
+            },
+            /* v8 ignore next 3 -- Bun websocket close callback forwarding is adapter glue; close is driven by Bun, not by unit tests. */
+            close(code, reason) {
+              socket.close(code, reason);
+            }
+          });
+        },
+        message(socket, message) {
+          const value = typeof message === "string" ? message : new TextDecoder().decode(message);
+          void runtime.receiveWebSocketMessage(socket.data.socketId, value).catch((error) => {
+            logSocketMessageError(socket.data.socketId, error);
+            runtime.disconnectWebSocket(socket.data.socketId);
+            socket.close(4001, "Protocol error");
+          });
+        },
+        close(socket) {
+          runtime.disconnectWebSocket(socket.data.socketId);
+        }
+      }
+    });
+    return Object.freeze({
+      host: config.worker.host,
+      port: config.worker.port,
+      async stop() {
+        server.stop(true);
+        await runtime.close();
+      }
+    });
+  }
+  let nodeWsModule;
+  try {
+    nodeWsModule = await (runtimeBindings.loadWebSocketModule ? runtimeBindings.loadWebSocketModule() : import("ws"));
+  } catch (error) {
+    await runtime.close();
+    const details = error instanceof Error ? error.message : String(error);
+    throw new Error(`[@holo-js/broadcast] Node runtime requires the "ws" package for broadcast:work. ${details}`);
+  }
+  const WebSocketServer = nodeWsModule.WebSocketServer;
+  if (typeof WebSocketServer !== "function") {
+    await runtime.close();
+    throw new Error("[@holo-js/broadcast] Node runtime websocket module is missing WebSocketServer export.");
+  }
+  const requestConnectionInfo = /* @__PURE__ */ new WeakMap();
+  const wsServer = new WebSocketServer({ noServer: true });
+  wsServer.on("connection", (socket, request) => {
+    const connectionInfo = requestConnectionInfo.get(request);
+    const socketId = connectionInfo.socketId;
+    runtime.connectWebSocket({
+      ...connectionInfo,
+      send(payload) {
+        socket.send(payload);
+      },
+      close(code, reason) {
+        socket.close(code, reason);
+      }
+    });
+    socket.on("message", (message) => {
+      const value = decodeNodeWebSocketMessage(message);
+      void runtime.receiveWebSocketMessage(socketId, value).catch((error) => {
+        logSocketMessageError(socketId, error);
+        runtime.disconnectWebSocket(socketId);
+        socket.close(4001, "Protocol error");
+      });
+    });
+    socket.on("close", () => {
+      runtime.disconnectWebSocket(socketId);
+    });
+  });
+  const httpServer = createServer(async (request, response) => {
+    const requestUrl = toNodeRequestUrl(request, `${config.worker.host}:${config.worker.port}`);
+    const requestBody = await readNodeRequestBody(request);
+    const requestInit = {
+      method: request.method,
+      headers: toNodeHeaders(request.headers)
+    };
+    if (typeof requestBody !== "undefined") {
+      requestInit.body = new Uint8Array(requestBody);
+    }
+    const runtimeRequest = new Request(requestUrl, {
+      ...requestInit
+    });
+    const runtimeResponse = await runtime.fetch(runtimeRequest);
+    await writeNodeResponse(response, runtimeResponse);
+  });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const requestUrl = new URL(toNodeRequestUrl(request, `${config.worker.host}:${config.worker.port}`));
+    const appMatch = requestUrl.pathname.match(appPathRegex);
+    if (!appMatch) {
+      socket.destroy();
+      return;
+    }
+    const app = appsByKey[appMatch[1]];
+    if (!app) {
+      socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    requestConnectionInfo.set(request, {
+      socketId: createSocketId(),
+      app,
+      headers: toNodeHeaders(request.headers)
+    });
+    wsServer.handleUpgrade(request, socket, head, (client, upgradedRequest) => {
+      wsServer.emit("connection", client, upgradedRequest);
+    });
+  });
+  try {
+    await new Promise((resolvePromise, rejectPromise) => {
+      httpServer.once("error", rejectPromise);
+      httpServer.listen(config.worker.port, config.worker.host, () => {
+        httpServer.off("error", rejectPromise);
+        resolvePromise();
+      });
+    });
+  } catch (error) {
+    wsServer.close();
+    await runtime.close();
+    throw error;
+  }
+  const address = httpServer.address();
+  const port = typeof address === "object" && address ? address.port : config.worker.port;
+  return Object.freeze({
+    host: config.worker.host,
+    port,
+    async stop() {
+      await new Promise((resolvePromise) => {
+        wsServer.close(() => {
+          resolvePromise();
+        });
+      });
+      httpServer.closeIdleConnections?.();
+      httpServer.closeAllConnections?.();
+      await new Promise((resolvePromise, rejectPromise) => {
+        httpServer.close((error) => {
+          if (error) {
+            rejectPromise(error);
+            return;
+          }
+          resolvePromise();
+        });
+      });
+      await runtime.close();
+    }
+  });
+}
+var workerInternals = {
+  buildWorkerApps,
+  createScalingNodeId,
+  createRedisScalingAdapter,
+  createPusherSignature,
+  createSocketId,
+  resolveRedisScalingConnection,
+  resolveScalingEventChannel,
+  normalizePublishBody,
+  parseChannelKind,
+  parsePresenceHashMembers,
+  parseSocketMessage
+};
+
+// src/index.ts
+import { defineBroadcastConfig } from "@holo-js/config";
+var broadcastPackage = Object.freeze({
+  authorizeBroadcastChannel,
+  broadcast,
+  broadcastRaw,
+  channel,
+  configureBroadcastRuntime,
+  defineBroadcast,
+  defineChannel,
+  getBroadcastRuntime,
+  getBroadcastRuntimeBindings,
+  parseBroadcastAuthEndpointPayload,
+  presenceChannel,
+  privateChannel,
+  renderBroadcastAuthResponse,
+  resetBroadcastRuntime,
+  resolveBroadcastWhisperSchema,
+  startBroadcastWorker,
+  validateBroadcastWhisperPayload,
+  createBroadcastWorkerRuntime
+});
+var src_default = broadcastPackage;
+export {
+  authorizeBroadcastChannel,
+  broadcast,
+  broadcastAuthInternals,
+  broadcastInternals,
+  broadcastRaw,
+  broadcastRegistryInternals,
+  broadcastRuntimeInternals,
+  channel,
+  configureBroadcastRuntime,
+  createBroadcastWorkerRuntime,
+  src_default as default,
+  defineBroadcast,
+  defineBroadcastConfig,
+  defineChannel,
+  getBroadcastRuntime,
+  getBroadcastRuntimeBindings,
+  getRegisteredBroadcastDriver,
+  isBroadcastDefinition,
+  isChannelDefinition,
+  listRegisteredBroadcastDrivers,
+  parseBroadcastAuthEndpointPayload,
+  presenceChannel,
+  privateChannel,
+  registerBroadcastDriver,
+  renderBroadcastAuthResponse,
+  resetBroadcastDriverRegistry,
+  resetBroadcastRuntime,
+  resolveBroadcastWhisperSchema,
+  startBroadcastWorker,
+  validateBroadcastWhisperPayload,
+  workerInternals
+};