@holo-js/broadcast 0.2.6 → 0.3.1

package/dist/index.mjs

@@ -6,7 +6,7 @@ import {
   resolveBroadcastChannelGuard,
   resolveBroadcastWhisperSchema,
   validateBroadcastWhisperPayload
-} from "./chunk-U5JDBKXC.mjs";
+} from "./chunk-JVDFH2TW.mjs";
 import {
   renderBroadcastClientConfigResponse,
   resolveBroadcastClientConfig
@@ -21,10 +21,17 @@ import {
   getBroadcastRuntimeBindings,
   getRegisteredBroadcastDriver,
   listRegisteredBroadcastDrivers,
+  loadBroadcastPluginDrivers,
   registerBroadcastDriver,
   resetBroadcastDriverRegistry,
+  resetBroadcastPluginDrivers,
   resetBroadcastRuntime
-} from "./chunk-TTKGDABI.mjs";
+} from "./chunk-6DCCSFFM.mjs";
+import {
+  defineBroadcastConfig,
+  holoBroadcastDefaults,
+  normalizeBroadcastConfig
+} from "./chunk-XLUGF257.mjs";
 import {
   broadcastInternals,
   channel,
@@ -40,23 +47,22 @@ import {
 } from "./chunk-HE6HN7ID.mjs";
 
 // src/worker.ts
-import { createHash, createHmac, randomInt, randomUUID, timingSafeEqual } from "crypto";
+import { createHash, createHmac as createHmac2, randomInt, randomUUID, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { createServer } from "http";
-var MAX_PUBLISH_TIMESTAMP_SKEW_SECONDS = 300;
-function normalizeRequiredString(value, label) {
+
+// src/workerProtocol.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function normalizeWorkerRequiredString(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 parseSocketMessage(rawMessage) {
+function parseWorkerSocketMessage(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 event = normalizeWorkerRequiredString(String(message.event ?? ""), "Websocket event");
+  const channel2 = typeof message.channel === "string" ? normalizeWorkerRequiredString(message.channel, "Websocket channel") : void 0;
   const data = typeof message.data === "string" ? parseJsonObject(message.data, "Websocket message data") : isPlainObject(message.data) ? message.data : {};
   return Object.freeze({
     event,
@@ -64,41 +70,12 @@ function parseSocketMessage(rawMessage) {
     data
   });
 }
-function normalizeRealtimeAction(value) {
-  if (value === "query" || value === "mutation" || value === "subscribe" || value === "unsubscribe") {
-    return value;
-  }
-  throw new Error("[@holo-js/broadcast] Realtime action is invalid.");
-}
-function normalizeRealtimeArgs(value) {
-  if (!isPlainObject(value)) {
-    return {};
-  }
-  return value;
-}
-function isRecord(value) {
-  return isObjectRecord(value);
-}
-function parseRealtimeSocketMessage(data) {
-  const id = normalizeRequiredString(String(data.id ?? ""), "Realtime request id");
-  const action = normalizeRealtimeAction(data.action);
-  const name = typeof data.name === "string" ? normalizeRequiredString(data.name, "Realtime definition name") : void 0;
-  if (action !== "unsubscribe" && !name) {
-    throw new Error("[@holo-js/broadcast] Realtime definition name is required.");
-  }
-  return Object.freeze({
-    id,
-    action,
-    ...typeof name === "undefined" ? {} : { name },
-    args: normalizeRealtimeArgs(data.args)
-  });
-}
-function normalizePublishBody(value) {
+function normalizeWorkerPublishBody(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") : "";
+  const name = typeof body.name === "string" ? normalizeWorkerRequiredString(body.name, "Publish name") : typeof body.event === "string" ? normalizeWorkerRequiredString(body.event, "Publish event") : "";
   if (!name) {
     throw new Error("[@holo-js/broadcast] Publish payload must include an event name.");
   }
@@ -106,13 +83,13 @@ function normalizePublishBody(value) {
     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")] : [];
+    return normalizeWorkerRequiredString(channel2, "Publish channel");
+  }) : typeof body.channel === "string" ? [normalizeWorkerRequiredString(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;
+  const socketId = typeof body.socket_id === "string" ? normalizeWorkerRequiredString(body.socket_id, "Publish socket_id") : void 0;
   return Object.freeze({
     name,
     channels: Object.freeze(channels),
@@ -120,19 +97,178 @@ function normalizePublishBody(value) {
     ...typeof socketId === "undefined" ? {} : { socket_id: socketId }
   });
 }
-function createPusherSignature(secret, method, pathname, params) {
+function createWorkerPusherSignature(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 verifyPusherSignature(providedSignature, expectedSignature) {
+function verifyWorkerPusherSignature(providedSignature, expectedSignature) {
   if (providedSignature.length !== expectedSignature.length || !/^[a-f0-9]+$/i.test(providedSignature) || !/^[a-f0-9]+$/i.test(expectedSignature)) {
     return false;
   }
   return timingSafeEqual(Buffer.from(providedSignature, "hex"), Buffer.from(expectedSignature, "hex"));
 }
+function parseWorkerChannelKind(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
+  });
+}
+
+// src/workerNodeTransport.ts
+var BroadcastPayloadTooLargeError = class extends Error {
+};
+async function readLimitedRequestText(request, maxBytes) {
+  const contentLength = Number(request.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new BroadcastPayloadTooLargeError();
+  }
+  if (!request.body) return "";
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const result = await reader.read();
+    if (result.done) break;
+    size += result.value.byteLength;
+    if (size > maxBytes) {
+      await reader.cancel();
+      throw new BroadcastPayloadTooLargeError();
+    }
+    chunks.push(result.value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+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);
+    } else {
+      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, maxBytes) {
+  if (request.method === "GET" || request.method === "HEAD") return void 0;
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.byteLength;
+    if (size > maxBytes) throw new BroadcastPayloadTooLargeError();
+    chunks.push(buffer);
+  }
+  return chunks.length === 0 ? void 0 : Buffer.concat(chunks);
+}
+function writeNodeRequestBodyError(response, error) {
+  if (error instanceof BroadcastPayloadTooLargeError) {
+    response.statusCode = 413;
+    response.end("Payload Too Large");
+    return;
+  }
+  response.statusCode = 500;
+  response.end("Internal Server Error");
+}
+async function writeNodeResponse(response, value) {
+  response.statusCode = value.status;
+  response.statusMessage = value.statusText;
+  value.headers.forEach((headerValue, headerName) => response.setHeader(headerName, headerValue));
+  response.end(Buffer.from(await value.arrayBuffer()));
+}
+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);
+}
+function getNodeWebSocketMessageBytes(message) {
+  if (typeof message === "string") return Buffer.byteLength(message);
+  if (message instanceof ArrayBuffer || message instanceof Uint8Array) return message.byteLength;
+  return message.reduce((size, chunk) => size + chunk.byteLength, 0);
+}
+
+// src/worker.ts
+function createScalingMessageListener(runtime) {
+  return (payload) => {
+    void runtime.receiveScalingMessage(payload).catch((error) => {
+      logScalingMessageError(error);
+    });
+  };
+}
+function isAllowedWorkerOrigin(request, allowedOrigins) {
+  const origin = request.headers.get("origin");
+  if (!origin) {
+    return true;
+  }
+  try {
+    const normalized = new URL(origin).origin;
+    return allowedOrigins.includes("*") || allowedOrigins.includes(normalized);
+  } catch {
+    return false;
+  }
+}
+var MAX_PUBLISH_TIMESTAMP_SKEW_SECONDS = 300;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeRealtimeAction(value) {
+  if (value === "query" || value === "mutation" || value === "subscribe" || value === "unsubscribe") {
+    return value;
+  }
+  throw new Error("[@holo-js/broadcast] Realtime action is invalid.");
+}
+function normalizeRealtimeArgs(value) {
+  if (!isPlainObject(value)) {
+    return {};
+  }
+  return value;
+}
+function isRecord(value) {
+  return isObjectRecord(value);
+}
+function parseRealtimeSocketMessage(data) {
+  const id = normalizeWorkerRequiredString(String(data.id ?? ""), "Realtime request id");
+  const action = normalizeRealtimeAction(data.action);
+  const name = typeof data.name === "string" ? normalizeWorkerRequiredString(data.name, "Realtime definition name") : void 0;
+  if (action !== "unsubscribe" && !name) {
+    throw new Error("[@holo-js/broadcast] Realtime definition name is required.");
+  }
+  return Object.freeze({
+    id,
+    action,
+    ...typeof name === "undefined" ? {} : { name },
+    args: normalizeRealtimeArgs(data.args)
+  });
+}
 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}`);
@@ -152,18 +288,18 @@ function logRealtimeSubscriptionCleanupError(socketId, subscriptionId, error) {
 function safeEqual(left, right) {
   const leftBuffer = Buffer.from(left);
   const rightBuffer = Buffer.from(right);
-  return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
+  return leftBuffer.length === rightBuffer.length && timingSafeEqual2(leftBuffer, rightBuffer);
 }
 function signChannelAuth(secret, socketId, channel2, channelData) {
   const value = channelData ? `${socketId}:${channel2}:${channelData}` : `${socketId}:${channel2}`;
-  return createHmac("sha256", secret).update(value).digest("hex");
+  return createHmac2("sha256", secret).update(value).digest("hex");
 }
 function parseClientChannelAuth(data) {
   if (typeof data.auth !== "string") {
     return void 0;
   }
   return Object.freeze({
-    auth: normalizeRequiredString(data.auth, "Subscription auth"),
+    auth: normalizeWorkerRequiredString(data.auth, "Subscription auth"),
     ...typeof data.channel_data === "string" ? { channelData: data.channel_data } : {}
   });
 }
@@ -174,7 +310,7 @@ function parseSignedChannelData(value) {
     });
   }
   const data = parseJsonObject(value, "Subscription channel data");
-  const whispers = Array.isArray(data.whispers) ? Object.freeze(data.whispers.map((item) => normalizeRequiredString(String(item), "Auth whisper"))) : Object.freeze([]);
+  const whispers = Array.isArray(data.whispers) ? Object.freeze(data.whispers.map((item) => normalizeWorkerRequiredString(String(item), "Auth whisper"))) : Object.freeze([]);
   const member = data.member && typeof data.member === "object" && !Array.isArray(data.member) ? Object.freeze(data.member) : void 0;
   return Object.freeze({
     whispers,
@@ -202,29 +338,11 @@ function unsubscribeRealtimeSubscription(socket, id, subscription) {
 function isRealtimeSubscriptionCurrent(socket, id, token) {
   return socket.active && socket.realtimeSubscriptionTokens.get(id) === token;
 }
-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");
+  return normalizeWorkerRequiredString(`${process.env.HOSTNAME ?? "node"}-${randomUUID()}`, "Broadcast worker node id");
 }
 function resolveScalingEventChannel(connection) {
   return `holo:broadcast:scaling:${connection}:events`;
@@ -271,14 +389,15 @@ function parsePresenceHashMembers(values) {
 function resolveRedisScalingConnection(queueConfig, connectionName, redisConfig) {
   const queueConnection = queueConfig?.connections[connectionName];
   if (queueConnection?.driver === "redis") {
+    const redisQueueConnection = queueConnection;
     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
+      ...typeof redisQueueConnection.redis.url === "undefined" ? {} : { url: redisQueueConnection.redis.url },
+      ...typeof redisQueueConnection.redis.clusters === "undefined" ? {} : { clusters: redisQueueConnection.redis.clusters },
+      host: redisQueueConnection.redis.host,
+      port: redisQueueConnection.redis.port,
+      username: redisQueueConnection.redis.username,
+      password: redisQueueConnection.redis.password,
+      db: redisQueueConnection.redis.db
     });
   }
   const redisConnection = redisConfig?.connections[connectionName];
@@ -481,7 +600,7 @@ function buildWorkerApps(config) {
       continue;
     }
     const holoConnection = connection;
-    const authEndpoint = typeof holoConnection.clientOptions.authEndpoint === "string" ? normalizeRequiredString(holoConnection.clientOptions.authEndpoint, `Broadcast connection "${name}" authEndpoint`) : void 0;
+    const authEndpoint = typeof holoConnection.clientOptions.authEndpoint === "string" ? normalizeWorkerRequiredString(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.`);
     }
@@ -506,7 +625,7 @@ function pusherEvent(event, data, channel2) {
   });
 }
 async function authenticateSubscription(app, connection, channel2, clientAuth, channelAuth, fetcher) {
-  const { kind, canonical } = parseChannelKind(channel2);
+  const { kind, canonical } = parseWorkerChannelKind(channel2);
   if (kind === "public") {
     return Object.freeze({
       whispers: Object.freeze([])
@@ -534,7 +653,7 @@ async function authenticateSubscription(app, connection, channel2, clientAuth, c
       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 whispers = Array.isArray(body.whispers) ? Object.freeze(body.whispers.map((value) => normalizeWorkerRequiredString(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,
@@ -567,6 +686,42 @@ async function authenticateSubscription(app, connection, channel2, clientAuth, c
     ...authorized.type === "presence" ? { member: authorized.member } : {}
   });
 }
+function resolveRealtimeErrorStatus(error) {
+  if (!isRecord(error)) {
+    return void 0;
+  }
+  const decision = isRecord(error.decision) ? error.decision : void 0;
+  const status = decision?.status ?? error.status ?? error.statusCode;
+  if (typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599) {
+    return status;
+  }
+  const name = typeof error.name === "string" ? error.name : "";
+  if (name === "RealtimeUnauthorizedError") {
+    return 401;
+  }
+  if (name === "RealtimeForbiddenError") {
+    return 403;
+  }
+  return void 0;
+}
+function resolveRealtimeErrorCode(error) {
+  if (!isRecord(error)) {
+    return void 0;
+  }
+  const decision = isRecord(error.decision) ? error.decision : void 0;
+  const code = decision?.code ?? error.code;
+  return typeof code === "string" ? code : void 0;
+}
+function resolveRealtimeErrorKind(error, status) {
+  if (!isRecord(error)) {
+    return "runtime";
+  }
+  const name = typeof error.name === "string" ? error.name : "";
+  if (name === "AuthorizationError" || name === "RealtimeUnauthorizedError" || name === "RealtimeForbiddenError" || status === 401 || status === 403 || status === 404) {
+    return "authorization";
+  }
+  return name === "RealtimeAuthUnavailableError" ? "transport" : "runtime";
+}
 function createBroadcastWorkerRuntime(options) {
   const appsByKey = buildWorkerApps(options.config);
   const connectedSockets = /* @__PURE__ */ new Map();
@@ -576,14 +731,12 @@ function createBroadcastWorkerRuntime(options) {
   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 () => {
+  const scalingUnsubscribe = options.scalingUnsubscribe ? Promise.resolve(options.scalingUnsubscribe) : scaling && options.scalingAutoSubscribe !== false ? scaling.adapter.subscribe(scaling.eventChannel, createScalingMessageListener({
+    receiveScalingMessage: handleScalingMessage
+  })) : Promise.resolve(async () => {
   });
   function createPresenceSocketRef(channel2, socketId) {
-    return scaling && parseChannelKind(channel2).kind === "presence" ? createNodeSocketRef(scaling.nodeId, socketId) : socketId;
+    return scaling && parseWorkerChannelKind(channel2).kind === "presence" ? createNodeSocketRef(scaling.nodeId, socketId) : socketId;
   }
   function setPresenceState(key, socketMembers) {
     if (socketMembers.size === 0) {
@@ -617,7 +770,7 @@ function createBroadcastWorkerRuntime(options) {
     if (!scaling) {
       return;
     }
-    const { kind } = parseChannelKind(channel2);
+    const { kind } = parseWorkerChannelKind(channel2);
     if (kind !== "presence") {
       return;
     }
@@ -751,42 +904,6 @@ function createBroadcastWorkerRuntime(options) {
     }
     socket.send(pusherEvent(event, data));
   }
-  function resolveRealtimeErrorStatus(error) {
-    if (!isRecord(error)) {
-      return void 0;
-    }
-    const decision = isRecord(error.decision) ? error.decision : void 0;
-    const status = decision?.status ?? error.status ?? error.statusCode;
-    if (typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599) {
-      return status;
-    }
-    const name = typeof error.name === "string" ? error.name : "";
-    if (name === "RealtimeUnauthorizedError") {
-      return 401;
-    }
-    if (name === "RealtimeForbiddenError") {
-      return 403;
-    }
-    return void 0;
-  }
-  function resolveRealtimeErrorCode(error) {
-    if (!isRecord(error)) {
-      return void 0;
-    }
-    const decision = isRecord(error.decision) ? error.decision : void 0;
-    const code = decision?.code ?? error.code;
-    return typeof code === "string" ? code : void 0;
-  }
-  function resolveRealtimeErrorKind(error, status) {
-    if (!isRecord(error)) {
-      return "runtime";
-    }
-    const name = typeof error.name === "string" ? error.name : "";
-    if (name === "AuthorizationError" || name === "RealtimeUnauthorizedError" || name === "RealtimeForbiddenError" || status === 401 || status === 403 || status === 404) {
-      return "authorization";
-    }
-    return name === "RealtimeAuthUnavailableError" ? "transport" : "runtime";
-  }
   function sendRealtimeError(socket, id, error) {
     const status = resolveRealtimeErrorStatus(error);
     const code = resolveRealtimeErrorCode(error);
@@ -1015,7 +1132,7 @@ function createBroadcastWorkerRuntime(options) {
     }
   }
   async function handleSubscribe(socket, rawChannel, clientAuth) {
-    const channel2 = normalizeRequiredString(rawChannel, "Subscription channel");
+    const channel2 = normalizeWorkerRequiredString(rawChannel, "Subscription channel");
     const authorization = await authenticateSubscription(socket.app, socket, channel2, clientAuth, options.channelAuth, options.fetch);
     if (!socket.active || connectedSockets.get(socket.socketId) !== socket) {
       return;
@@ -1034,7 +1151,7 @@ function createBroadcastWorkerRuntime(options) {
         channelWhispers.delete(key);
       }
     }
-    const { kind } = parseChannelKind(channel2);
+    const { kind } = parseWorkerChannelKind(channel2);
     if (kind === "presence") {
       const member = authorization.member ?? Object.freeze({ id: socket.socketId });
       const synchronized = await synchronizePresenceChannel(
@@ -1056,7 +1173,7 @@ function createBroadcastWorkerRuntime(options) {
     socket.send(pusherEvent("pusher_internal:subscription_succeeded", {}, channel2));
   }
   async function handleUnsubscribe(socket, rawChannel) {
-    const channel2 = normalizeRequiredString(rawChannel, "Unsubscribe channel");
+    const channel2 = normalizeWorkerRequiredString(rawChannel, "Unsubscribe channel");
     socket.subscribedChannels.delete(channel2);
     const removedPresenceMember = removeSubscriptionLocal(socket.app.appId, socket.socketId, channel2);
     if (removedPresenceMember.removed && removedPresenceMember.member) {
@@ -1069,11 +1186,11 @@ function createBroadcastWorkerRuntime(options) {
     socket.send(pusherEvent("pusher_internal:unsubscribed", {}, channel2));
   }
   async function handleClientEvent(socket, message) {
-    const channel2 = normalizeRequiredString(message.channel ?? "", "Whisper channel");
+    const channel2 = normalizeWorkerRequiredString(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);
+    const { kind, canonical } = parseWorkerChannelKind(channel2);
     if (kind === "public") {
       throw new Error("[@holo-js/broadcast] Client events are only allowed on private or presence channels.");
     }
@@ -1092,15 +1209,9 @@ function createBroadcastWorkerRuntime(options) {
       appId: socket.app.appId,
       socket_id: socket.socketId
     });
-    await publishToChannels(payload, {
-      fromScaling: false,
-      shouldReplicate: true
-    });
+    await publishToChannels(payload);
   }
-  async function publishToChannels(body, options2 = {
-    fromScaling: false,
-    shouldReplicate: true
-  }) {
+  async function publishToChannels(body) {
     let deliveredSockets = 0;
     const deliveredChannels = [];
     for (const channel2 of body.channels) {
@@ -1110,9 +1221,7 @@ function createBroadcastWorkerRuntime(options) {
       }
       deliveredSockets += result.deliveredSockets;
     }
-    if (!options2.fromScaling && options2.shouldReplicate) {
-      await publishScalingEvent(body);
-    }
+    await publishScalingEvent(body);
     return Object.freeze({
       deliveredChannels: Object.freeze(deliveredChannels),
       deliveredSockets
@@ -1121,19 +1230,27 @@ function createBroadcastWorkerRuntime(options) {
   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 appId = normalizeWorkerRequiredString(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();
+    let bodyText;
+    try {
+      bodyText = await readLimitedRequestText(request, options.config.worker.maxRequestBytes);
+    } catch (error) {
+      if (error instanceof BroadcastPayloadTooLargeError) {
+        return new Response("Payload Too Large", { status: 413 });
+      }
+      throw error;
+    }
     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");
+      authKey = normalizeWorkerRequiredString(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 });
@@ -1144,7 +1261,7 @@ function createBroadcastWorkerRuntime(options) {
     let authTimestamp;
     try {
       authTimestamp = Number.parseInt(
-        normalizeRequiredString(url.searchParams.get("auth_timestamp") ?? "", "Publish auth_timestamp"),
+        normalizeWorkerRequiredString(url.searchParams.get("auth_timestamp") ?? "", "Publish auth_timestamp"),
         10
       );
     } catch (error) {
@@ -1161,8 +1278,8 @@ function createBroadcastWorkerRuntime(options) {
     let providedSignature;
     let expectedSignature;
     try {
-      providedSignature = normalizeRequiredString(url.searchParams.get("auth_signature") ?? "", "Publish auth_signature");
-      expectedSignature = createPusherSignature(
+      providedSignature = normalizeWorkerRequiredString(url.searchParams.get("auth_signature") ?? "", "Publish auth_signature");
+      expectedSignature = createWorkerPusherSignature(
         app.secret,
         request.method,
         url.pathname,
@@ -1172,12 +1289,12 @@ function createBroadcastWorkerRuntime(options) {
       const message = error instanceof Error ? error.message : "Invalid auth signature";
       return new Response(message, { status: 401 });
     }
-    if (!verifyPusherSignature(providedSignature, expectedSignature)) {
+    if (!verifyWorkerPusherSignature(providedSignature, expectedSignature)) {
       return new Response("Invalid auth signature", { status: 401 });
     }
     let publishBody;
     try {
-      publishBody = normalizePublishBody(parseJsonObject(bodyText, "Publish body"));
+      publishBody = normalizeWorkerPublishBody(parseJsonObject(bodyText, "Publish body"));
     } catch (error) {
       return new Response(error.message, { status: 400 });
     }
@@ -1186,9 +1303,6 @@ function createBroadcastWorkerRuntime(options) {
       result = await publishToChannels({
         ...publishBody,
         appId: app.appId
-      }, {
-        fromScaling: false,
-        shouldReplicate: true
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Broadcast publish failed.";
@@ -1217,7 +1331,7 @@ function createBroadcastWorkerRuntime(options) {
           }
         });
       }
-      if (request.method.toUpperCase() === "GET" && url.pathname === options.config.worker.statsPath) {
+      if (options.config.worker.statsEnabled && request.method.toUpperCase() === "GET" && url.pathname === options.config.worker.statsPath) {
         return new Response(JSON.stringify({
           ...this.getStats()
         }), {
@@ -1258,7 +1372,7 @@ function createBroadcastWorkerRuntime(options) {
         if (!socket.active || connectedSockets.get(socketId) !== socket) {
           return;
         }
-        const message = parseSocketMessage(rawMessage);
+        const message = parseWorkerSocketMessage(rawMessage);
         if (message.event === "pusher:ping") {
           socket.send(pusherEvent("pusher:pong", {}));
           return;
@@ -1320,11 +1434,8 @@ function createBroadcastWorkerRuntime(options) {
         await Promise.all(scalingCleanupTasks.map(async (task) => {
           await task();
         }));
-      }).catch((error) => {
-        logSocketMessageError(socket.socketId, error);
-      });
-      socket.pendingMessage = cleanupTask.catch(() => {
       });
+      socket.pendingMessage = cleanupTask;
     },
     getStats() {
       return Object.freeze({
@@ -1355,64 +1466,6 @@ function createBroadcastWorkerRuntime(options) {
     }
   });
 }
-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();
@@ -1451,11 +1504,10 @@ async function startBroadcastWorker(runtimeBindings) {
     }
   });
   if (scalingConfig) {
-    scalingUnsubscribe = await scalingConfig.adapter.subscribe(scalingConfig.eventChannel, (payload) => {
-      void runtime.receiveScalingMessage(payload).catch((error) => {
-        logScalingMessageError(error);
-      });
-    }).catch((subscribeError) => handleSubscribeFailure(runtime, subscribeError));
+    scalingUnsubscribe = await scalingConfig.adapter.subscribe(
+      scalingConfig.eventChannel,
+      createScalingMessageListener(runtime)
+    ).catch((subscribeError) => handleSubscribeFailure(runtime, subscribeError));
   }
   const bun = globalThis.Bun;
   const appsByKey = buildWorkerApps(config);
@@ -1474,6 +1526,9 @@ async function startBroadcastWorker(runtimeBindings) {
           if (!app) {
             return new Response("Unknown app key", { status: 401 });
           }
+          if (!isAllowedWorkerOrigin(request, config.worker.allowedOrigins)) {
+            return new Response("Forbidden", { status: 403 });
+          }
           const upgraded = wsServer2.upgrade(request, {
             data: {
               socketId: createSocketId(),
@@ -1501,6 +1556,12 @@ async function startBroadcastWorker(runtimeBindings) {
           });
         },
         message(socket, message) {
+          const messageBytes = typeof message === "string" ? Buffer.byteLength(message) : message.byteLength;
+          if (messageBytes > config.worker.maxMessageBytes) {
+            runtime.disconnectWebSocket(socket.data.socketId);
+            socket.close(1009, "Message too large");
+            return;
+          }
           const value = typeof message === "string" ? message : new TextDecoder().decode(message);
           void runtime.receiveWebSocketMessage(socket.data.socketId, value).catch((error) => {
             logSocketMessageError(socket.data.socketId, error);
@@ -1536,7 +1597,7 @@ async function startBroadcastWorker(runtimeBindings) {
     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 });
+  const wsServer = new WebSocketServer({ noServer: true, maxPayload: config.worker.maxMessageBytes });
   wsServer.on("connection", (socket, request) => {
     const connectionInfo = requestConnectionInfo.get(request);
     const socketId = connectionInfo.socketId;
@@ -1550,6 +1611,12 @@ async function startBroadcastWorker(runtimeBindings) {
       }
     });
     socket.on("message", (message) => {
+      const messageBytes = getNodeWebSocketMessageBytes(message);
+      if (messageBytes > config.worker.maxMessageBytes) {
+        runtime.disconnectWebSocket(socketId);
+        socket.close(1009, "Message too large");
+        return;
+      }
       const value = decodeNodeWebSocketMessage(message);
       void runtime.receiveWebSocketMessage(socketId, value).catch((error) => {
         logSocketMessageError(socketId, error);
@@ -1563,7 +1630,13 @@ async function startBroadcastWorker(runtimeBindings) {
   });
   const httpServer = createServer(async (request, response) => {
     const requestUrl = toNodeRequestUrl(request, `${config.worker.host}:${config.worker.port}`);
-    const requestBody = await readNodeRequestBody(request);
+    let requestBody;
+    try {
+      requestBody = await readNodeRequestBody(request, config.worker.maxRequestBytes);
+    } catch (error) {
+      writeNodeRequestBodyError(response, error);
+      return;
+    }
     const requestInit = {
       method: request.method,
       headers: toNodeHeaders(request.headers)
@@ -1590,6 +1663,12 @@ async function startBroadcastWorker(runtimeBindings) {
       socket.destroy();
       return;
     }
+    const originRequest = new Request(requestUrl, { headers: toNodeHeaders(request.headers) });
+    if (!isAllowedWorkerOrigin(originRequest, config.worker.allowedOrigins)) {
+      socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+      socket.destroy();
+      return;
+    }
     requestConnectionInfo.set(request, {
       socketId: createSocketId(),
       app,
@@ -1642,19 +1721,37 @@ var workerInternals = {
   buildWorkerApps,
   createScalingNodeId,
   createRedisScalingAdapter,
-  createPusherSignature,
-  verifyPusherSignature,
+  createPusherSignature: createWorkerPusherSignature,
+  verifyPusherSignature: verifyWorkerPusherSignature,
   createSocketId,
   resolveRedisScalingConnection,
   resolveScalingEventChannel,
-  normalizePublishBody,
-  parseChannelKind,
+  normalizePublishBody: normalizeWorkerPublishBody,
+  parseChannelKind: parseWorkerChannelKind,
   parsePresenceHashMembers,
-  parseSocketMessage
+  parseSocketMessage: parseWorkerSocketMessage,
+  isAllowedWorkerOrigin,
+  readLimitedRequestText,
+  normalizeRealtimeAction,
+  normalizeRealtimeArgs,
+  parseRealtimeSocketMessage,
+  logSocketMessageError,
+  logScalingMessageError,
+  logSocketCleanupError,
+  logRealtimeSubscriptionCleanupError,
+  safeEqual,
+  signChannelAuth,
+  parseClientChannelAuth,
+  parseSignedChannelData,
+  verifyClientChannelAuth,
+  resolvePresenceMemberId,
+  resolveRealtimeErrorStatus,
+  resolveRealtimeErrorCode,
+  resolveRealtimeErrorKind,
+  writeNodeRequestBodyError
 };
 
 // src/index.ts
-import { defineBroadcastConfig } from "@holo-js/config";
 var broadcastPackage = Object.freeze({
   authorizeBroadcastChannel,
   broadcast,
@@ -1697,9 +1794,12 @@ export {
   getBroadcastRuntime,
   getBroadcastRuntimeBindings,
   getRegisteredBroadcastDriver,
+  holoBroadcastDefaults,
   isBroadcastDefinition,
   isChannelDefinition,
   listRegisteredBroadcastDrivers,
+  loadBroadcastPluginDrivers,
+  normalizeBroadcastConfig,
   parseBroadcastAuthEndpointPayload,
   presenceChannel,
   privateChannel,
@@ -1707,6 +1807,7 @@ export {
   renderBroadcastAuthResponse,
   renderBroadcastClientConfigResponse,
   resetBroadcastDriverRegistry,
+  resetBroadcastPluginDrivers,
   resetBroadcastRuntime,
   resolveBroadcastChannelGuard,
   resolveBroadcastClientConfig,