@beignet/core 0.0.53 → 0.0.54

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @beignet/core
 
+## 0.0.54
+
+### Patch Changes
+
+- b71b34f: Add typed, authorized browser broadcasting with bounded SSE connections, memory
+  and Redis providers, reconnect reconciliation, React Query invalidation,
+  initiating-client exclusion, notification delivery, and transactional inbox
+  scaffolding. Raw routes now preserve context added by route hooks.
+
 ## 0.0.53
 
 ### Patch Changes

package/README.md

@@ -11,7 +11,7 @@
 This package provides Beignet's framework primitives: contracts, server runtime,
 typed client, use cases, agent capabilities, ports, domain helpers, app errors, config, events,
 idempotency, locks, outbox, mail, notifications, payments, search, webhooks,
-feature flags, error reporting, encryption, schedules, uploads, entitlements, pagination
+feature flags, error reporting, encryption, broadcasting, schedules, uploads, entitlements, pagination
 helpers, testing helpers, and OpenAPI generation.
 
 ## Installation
@@ -50,6 +50,9 @@ name the framework area they depend on.
 | --- | --- |
 | `@beignet/core/agent-capabilities` | Typed agent capability definitions, registries, validation, and execution |
 | `@beignet/core/application` | Use case builder and test helpers |
+| `@beignet/core/broadcasting` | Browser-safe typed channel definitions and transport validation |
+| `@beignet/core/broadcasting/server` | BroadcastPort, authorization bindings, registry, and authenticated origins |
+| `@beignet/core/broadcasting/client` | Multiplexed streaming browser client with reconnect reconciliation |
 | `@beignet/core/client` | Typed HTTP client |
 | `@beignet/core/client-only` | Static lint marker for modules intended for client-side imports |
 | `@beignet/core/config` | Environment config validation |
@@ -1176,7 +1179,7 @@ contracts should stay on explicit paths; catch-all contract patterns such as
 For routes that cannot be contracts at all — third-party callback endpoints
 with externally defined request shapes, signature-verified webhooks,
 streaming endpoints that own body consumption —
-`server.rawRoute({ name, method, path, metadata }).handle(fn)` builds a
+`server.rawRoute({ name, method, path, metadata, hooks }).handle(fn)` builds a
 handler that still runs the whole pipeline (hooks, context creation,
 instrumentation, framework error mapping) without contract parsing or
 validation. The request body stays unconsumed for the handler, `metadata`
@@ -2743,6 +2746,65 @@ field requiredness, descriptions, and constraints.
 - [`@beignet/nuqs`](https://beignetjs.com/nuqs) - URL query state integration with nuqs
 - [`@beignet/devtools`](https://beignetjs.com/devtools) - Local request, provider, and audit timeline
 
+## Broadcasting
+
+Define browser-safe channels with `defineChannel(name, { params, events })` from
+`@beignet/core/broadcasting`. Parameters parse to flat string records; event
+schemas produce stable canonical JSON. `BroadcastValidationError` rejects
+invalid data and non-idempotent transforms.
+
+On the server, import `BroadcastPort` and `createBroadcasting<AppContext>()`
+from `@beignet/core/broadcasting/server`. Its `defineChannelBinding` requires an
+explicit authorization callback for every channel, and `defineChannelRegistry`
+rejects duplicate names. Use memory or Redis providers and expose the registry
+with `createBroadcastRoute` from `@beignet/web` or `@beignet/next`.
+
+```ts
+import { defineChannel } from "@beignet/core/broadcasting";
+import { z } from "zod";
+
+export const changes = defineChannel("issues.changes", {
+  params: z.object({ workspaceId: z.string() }),
+  events: { changed: z.object({ issueId: z.string() }) },
+});
+```
+
+`broadcast.publish(changes, { params, event: "changed", data })` resolves on
+provider acceptance. `broadcast.subscribe(changes, { params, onEvent,
+onDisconnect })` returns `{ ready, unsubscribe }`; await readiness and cleanup.
+Publish after commit, or record a publication job in the transaction's outbox
+when the attempt must be retryable. Browser delivery is ephemeral.
+
+`createBroadcastClient({ url, headers?, credentials?, fetch? })` from
+`@beignet/core/broadcasting/client` shares one streaming Fetch connection.
+Subscribe with `{ params, onEvent, onSync, onError?, onStatusChange? }` and use
+`onSync` to refetch after initial readiness and recovery. Each subscription
+exposes `unsubscribe()` and `getStatus()`. The client also exposes `getStatus()`,
+`resume()`, `close()`, and `getRequestHeaders()` for opt-in origin exclusion.
+Create a fresh client on user/workspace changes. Callbacks that already started
+remain application-owned work after unsubscribe.
+
+`resolveBroadcastOrigin({ headers, principalId, tenantId, namespace })` binds
+the optional client header to authenticated server identity. Forward a captured
+origin through a job as `broadcastOrigin`, validate with `broadcastOriginSchema`
+when using Standard Schema directly, and pass it as `excludeOrigin` to publish.
+Use the same resolver on the stream endpoint. Missing, malformed, or anonymous
+origins disable exclusion. Default redaction hides origin headers and fields.
+
+`defineBroadcastNotificationChannel({ channel, render })` from
+`@beignet/core/notifications` publishes rendered notifications through the port;
+return `undefined` to skip. Existing preferences and per-channel retries apply.
+A sent result means provider acceptance. Persistent inbox writes and their
+publication jobs must share an app-owned transaction; independent notification
+channels have no execution ordering guarantee.
+
+The browser protocol has no replay IDs. Limits are 20 subscriptions, an 8 KiB
+encoded request, 64 KiB event data, 1 MiB buffers, 25-second heartbeats,
+10-second readiness waits, and streams renewed within 60 seconds. Terminal 4xx
+responses block until explicit resume; 429/5xx retry with jitter and respect
+`Retry-After`. Retry deadlines survive subscription changes. See the
+[broadcasting guide](https://beignetjs.com/broadcasting).
+
 ## License
 
 MIT

package/dist/broadcasting/client.d.ts

@@ -0,0 +1,38 @@
+import { type ChannelDefinition, type InferChannelEvent, type InferChannelParams } from "./index.js";
+export type BroadcastClientStatus = "connecting" | "connected" | "reconnecting" | "blocked" | "closed";
+/** Safe connection/protocol failure; application callback errors are reported separately. */
+export declare class BroadcastClientError extends Error {
+    readonly retryable: boolean;
+    readonly status?: number | undefined;
+    constructor(message: string, retryable: boolean, status?: number | undefined);
+}
+export interface BroadcastClientSubscription {
+    unsubscribe(): void;
+    getStatus(): BroadcastClientStatus;
+}
+export interface BroadcastClient {
+    subscribe<C extends ChannelDefinition>(channel: C, options: {
+        params: InferChannelParams<C>;
+        onEvent: (event: InferChannelEvent<C>) => void | Promise<void>;
+        /** Refetch authoritative state after initial readiness and every recovered connection. */
+        onSync: () => void | Promise<void>;
+        onError?: (error: unknown) => void;
+        onStatusChange?: (status: BroadcastClientStatus) => void;
+    }): BroadcastClientSubscription;
+    /** Merge these optional headers into the app's typed HTTP client to opt into exclusion. */
+    getRequestHeaders(): Record<string, string>;
+    getStatus(): BroadcastClientStatus;
+    /** Explicit app action after credentials/access change. Renewals never unblock denied subscriptions. */
+    resume(): void;
+    close(): void;
+}
+export interface BroadcastClientOptions {
+    url: string;
+    /** Resolved afresh for every request. Never place credentials in the URL. */
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    credentials?: RequestCredentials;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+/** One multiplexed streaming Fetch connection per instance. Create an instance per app auth session. */
+export declare function createBroadcastClient(options: BroadcastClientOptions): BroadcastClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/broadcasting/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/broadcasting/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAGxB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,qBAAqB,GAC7B,YAAY,GACZ,WAAW,GACX,cAAc,GACd,SAAS,GACT,QAAQ,CAAC;AAEb,6FAA6F;AAC7F,qBAAa,oBAAqB,SAAQ,KAAK;IAG3C,QAAQ,CAAC,SAAS,EAAE,OAAO;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM;gBAFxB,OAAO,EAAE,MAAM,EACN,SAAS,EAAE,OAAO,EAClB,MAAM,CAAC,EAAE,MAAM,YAAA;CAK3B;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,IAAI,IAAI,CAAC;IACpB,SAAS,IAAI,qBAAqB,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,CAAC,SAAS,iBAAiB,EACnC,OAAO,EAAE,CAAC,EACV,OAAO,EAAE;QACP,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAC9B,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC/D,0FAA0F;QAC1F,MAAM,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;QACnC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;KAC1D,GACA,2BAA2B,CAAC;IAC/B,2FAA2F;IAC3F,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,SAAS,IAAI,qBAAqB,CAAC;IACnC,wGAAwG;IACxG,MAAM,IAAI,IAAI,CAAC;IACf,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,OAAO,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IACnE,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC7E;AAyDD,wGAAwG;AACxG,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CAglBjB"}

package/dist/broadcasting/client.js

@@ -0,0 +1,519 @@
+import { BroadcastValidationError, broadcastLimits, channelKey, parseChannelEvent, parseChannelParams, } from "./index.js";
+/** Safe connection/protocol failure; application callback errors are reported separately. */
+export class BroadcastClientError extends Error {
+    retryable;
+    status;
+    constructor(message, retryable, status) {
+        super(message);
+        this.retryable = retryable;
+        this.status = status;
+        this.name = "BroadcastClientError";
+    }
+}
+function retryDelay(failures, minimum = 0) {
+    const ceiling = Math.min(30_000, 1_000 * 2 ** Math.min(failures, 5));
+    return Math.max(minimum, Math.round(ceiling * (0.5 + Math.random() * 0.5)));
+}
+function responseRetryDelay(response) {
+    const value = response.headers.get("retry-after");
+    if (!value)
+        return 0;
+    const seconds = Number(value);
+    const delay = Number.isFinite(seconds)
+        ? seconds * 1_000
+        : Date.parse(value) - Date.now();
+    return Number.isFinite(delay) ? Math.max(0, delay) : 0;
+}
+/** Stop waiting even if an application schema/header callback ignores cancellation. */
+async function abortable(work, signal) {
+    let cancel = () => { };
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                cancel = () => reject(new BroadcastClientError("Broadcast operation interrupted", true));
+                if (signal.aborted)
+                    cancel();
+                else
+                    signal.addEventListener("abort", cancel, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        signal.removeEventListener("abort", cancel);
+    }
+}
+/** One multiplexed streaming Fetch connection per instance. Create an instance per app auth session. */
+export function createBroadcastClient(options) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const clientId = crypto.randomUUID();
+    const entries = new Map();
+    const observers = new Set();
+    let nextId = 0;
+    let closed = false;
+    let generation = 0;
+    let controller;
+    let retryTimer;
+    let restartQueued = false;
+    let attempted = false;
+    function status(entry) {
+        if (closed)
+            return "closed";
+        if (entry?.blocked)
+            return "blocked";
+        if (entry?.ready)
+            return "connected";
+        if (!entry && [...entries.values()].some((value) => value.ready))
+            return "connected";
+        if (!entry &&
+            entries.size > 0 &&
+            [...entries.values()].every((value) => value.blocked))
+            return "blocked";
+        return attempted ? "reconnecting" : "connecting";
+    }
+    function report(observer, error) {
+        if (!observer.active)
+            return;
+        try {
+            observer.onError?.(error);
+        }
+        catch {
+            /* Error reporting cannot change transport state. */
+        }
+    }
+    function invoke(observer, callback) {
+        if (!observer.active)
+            return;
+        try {
+            void Promise.resolve(callback()).catch((error) => report(observer, error));
+        }
+        catch (error) {
+            report(observer, error);
+        }
+    }
+    function notify(entry) {
+        for (const observer of entry.observers)
+            invoke(observer, () => observer.onStatusChange?.(status(entry)));
+    }
+    function fail(entry, error, minimum = 0) {
+        entry.ready = false;
+        entry.blocked = !error.retryable;
+        if (error.retryable)
+            entry.nextAttemptAt = Date.now() + retryDelay(entry.failures++, minimum);
+        notify(entry);
+        for (const observer of entry.observers)
+            report(observer, error);
+    }
+    function clearRetry() {
+        if (retryTimer !== undefined)
+            clearTimeout(retryTimer);
+        retryTimer = undefined;
+    }
+    function scheduleRetry() {
+        clearRetry();
+        const waiting = [...entries.values()].filter((entry) => !entry.blocked && !entry.ready && entry.nextAttemptAt > 0);
+        if (!waiting.length || closed)
+            return;
+        const delay = Math.max(0, Math.min(...waiting.map((entry) => entry.nextAttemptAt)) - Date.now());
+        // Long Retry-After values retain their deadline across timer chunks and subscription changes.
+        retryTimer = setTimeout(() => {
+            if (waiting.some((entry) => !entry.blocked && entry.nextAttemptAt <= Date.now()))
+                restart();
+            else
+                scheduleRetry();
+        }, Math.min(delay, 2_147_483_647));
+    }
+    function restart() {
+        if (closed)
+            return;
+        generation++;
+        controller?.abort();
+        controller = undefined;
+        clearRetry();
+        for (const entry of entries.values()) {
+            entry.ready = false;
+            notify(entry);
+        }
+        if (restartQueued)
+            return;
+        restartQueued = true;
+        queueMicrotask(() => {
+            restartQueued = false;
+            if (!closed)
+                void connect(generation);
+        });
+    }
+    async function connect(current) {
+        const included = [...entries.values()].filter((entry) => !entry.blocked && entry.nextAttemptAt <= Date.now());
+        if (!included.length) {
+            scheduleRetry();
+            return;
+        }
+        for (const entry of included)
+            entry.nextAttemptAt = 0;
+        // Joining channels must not cancel deadlines for subscriptions still waiting to retry.
+        scheduleRetry();
+        attempted = true;
+        const abort = new AbortController();
+        controller = abort;
+        const live = () => !closed && current === generation && !abort.signal.aborted;
+        let reader;
+        let timer;
+        let lifetime;
+        let readiness;
+        const arm = (ms) => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            timer = setTimeout(() => abort.abort(), ms);
+        };
+        let terminal = false;
+        let reading = false;
+        try {
+            arm(broadcastLimits.readyTimeoutMs);
+            const url = new URL(options.url, typeof location === "undefined" ? "http://localhost" : location.href);
+            if (url.username ||
+                url.password ||
+                !["http:", "https:"].includes(url.protocol))
+                throw new BroadcastClientError("Invalid broadcast endpoint URL", false);
+            url.searchParams.set("subscriptions", JSON.stringify({
+                version: 1,
+                channels: included.map((entry) => ({
+                    id: entry.id,
+                    name: entry.channel.name,
+                    params: entry.params,
+                })),
+            }));
+            if (new TextEncoder().encode(url.search).byteLength >
+                broadcastLimits.requestBytes)
+                throw new BroadcastClientError("Broadcast subscriptions exceed the request size limit", false);
+            const headers = new Headers(typeof options.headers === "function"
+                ? await abortable(Promise.resolve().then(options.headers), abort.signal)
+                : options.headers);
+            if (!live())
+                return;
+            headers.set("Accept", "text/event-stream");
+            headers.set("X-Beignet-Broadcast-Client", clientId);
+            headers.delete("Last-Event-ID");
+            const fetching = fetcher(url, {
+                method: "GET",
+                headers,
+                credentials: options.credentials ?? "same-origin",
+                cache: "no-store",
+                redirect: "error",
+                signal: abort.signal,
+            });
+            void fetching.then((response) => {
+                if (!live())
+                    void response.body?.cancel().catch(() => undefined);
+            }, () => undefined);
+            const response = await abortable(fetching, abort.signal);
+            if (!live())
+                return;
+            if (!response.ok) {
+                terminal = true;
+                const retryable = response.status === 429 || response.status >= 500;
+                for (const entry of included)
+                    fail(entry, new BroadcastClientError("Broadcast connection was rejected", retryable, response.status), responseRetryDelay(response));
+                void response.body?.cancel().catch(() => undefined);
+                return;
+            }
+            if (response.headers.get("content-type")?.split(";", 1)[0]?.trim() !==
+                "text/event-stream" ||
+                !response.body)
+                throw new BroadcastClientError("Invalid broadcast response", false);
+            reader = response.body.getReader();
+            reading = true;
+            arm(broadcastLimits.heartbeatMs * 2 + 5_000);
+            lifetime = setTimeout(() => abort.abort(), broadcastLimits.maxLifetimeMs);
+            readiness = setTimeout(() => {
+                for (const entry of included)
+                    if (!entry.ready &&
+                        !entry.blocked &&
+                        entry.nextAttemptAt <= Date.now())
+                        fail(entry, new BroadcastClientError("Broadcast readiness timed out", true));
+                restart();
+            }, broadcastLimits.readyTimeoutMs);
+            const byId = new Map(included.map((entry) => [entry.id, entry]));
+            const decoder = new TextDecoder("utf-8", { fatal: true });
+            let buffer = "";
+            let data = [];
+            let eventName = "";
+            let frameBytes = 0;
+            async function line(value) {
+                if (!value) {
+                    if (data.length) {
+                        if (eventName !== "broadcast")
+                            throw new BroadcastClientError("Unknown broadcast frame", false);
+                        const frame = JSON.parse(data.join("\n"));
+                        if (!frame || typeof frame !== "object")
+                            throw new BroadcastClientError("Invalid broadcast frame", false);
+                        const message = frame;
+                        const entry = typeof message.id === "string" ? byId.get(message.id) : undefined;
+                        if (!entry || typeof message.type !== "string")
+                            throw new BroadcastClientError("Invalid broadcast subscription frame", false);
+                        if (entry.blocked || entry.nextAttemptAt > Date.now()) {
+                            data = [];
+                            eventName = "";
+                            frameBytes = 0;
+                            return;
+                        }
+                        if (message.type === "ready") {
+                            if (entry.ready)
+                                throw new BroadcastClientError("Duplicate broadcast readiness", false);
+                            entry.ready = true;
+                            entry.failures = 0;
+                            entry.nextAttemptAt = 0;
+                            notify(entry);
+                            for (const observer of entry.observers)
+                                invoke(observer, observer.onSync);
+                        }
+                        else if (message.type === "event") {
+                            if (!entry.ready || typeof message.event !== "string")
+                                throw new BroadcastClientError("Event before broadcast readiness", false);
+                            const event = await abortable(parseChannelEvent(entry.channel, {
+                                event: message.event,
+                                data: message.data,
+                            }), abort.signal);
+                            if (live())
+                                for (const observer of entry.observers)
+                                    invoke(observer, () => observer.onEvent(event));
+                        }
+                        else if (message.type === "rejected" ||
+                            message.type === "unavailable") {
+                            if (typeof message.status !== "number" ||
+                                !Number.isInteger(message.status) ||
+                                message.status < 400 ||
+                                message.status > 599)
+                                throw new BroadcastClientError("Invalid broadcast failure", false);
+                            const retryable = message.type === "unavailable";
+                            if (retryable !== (message.status === 429 || message.status >= 500))
+                                throw new BroadcastClientError("Invalid broadcast failure classification", false);
+                            const retryAfter = message.retryAfterMs;
+                            if (retryAfter !== undefined &&
+                                (typeof retryAfter !== "number" ||
+                                    !Number.isFinite(retryAfter) ||
+                                    retryAfter < 0))
+                                throw new BroadcastClientError("Invalid broadcast retry delay", false);
+                            fail(entry, new BroadcastClientError("Broadcast subscription is unavailable", retryable, message.status), typeof retryAfter === "number" ? retryAfter : 0);
+                            scheduleRetry();
+                        }
+                        else
+                            throw new BroadcastClientError("Unknown broadcast control frame", false);
+                        if (included.every((entry) => entry.ready ||
+                            entry.blocked ||
+                            entry.nextAttemptAt > Date.now())) {
+                            if (readiness !== undefined)
+                                clearTimeout(readiness);
+                            readiness = undefined;
+                        }
+                        if (included.every((entry) => entry.blocked || entry.nextAttemptAt > Date.now())) {
+                            terminal = true;
+                            abort.abort();
+                        }
+                    }
+                    data = [];
+                    eventName = "";
+                    frameBytes = 0;
+                    return;
+                }
+                frameBytes += new TextEncoder().encode(value).byteLength;
+                if (frameBytes >
+                    broadcastLimits.payloadBytes + broadcastLimits.requestBytes)
+                    throw new BroadcastClientError("Broadcast frame exceeds the size limit", false);
+                if (value.startsWith(":"))
+                    return;
+                const colon = value.indexOf(":");
+                const field = colon < 0 ? value : value.slice(0, colon);
+                const content = colon < 0 ? "" : value.slice(colon + 1).replace(/^ /, "");
+                if (field === "data")
+                    data.push(content);
+                else if (field === "event")
+                    eventName = content;
+                else if (field === "id" || field === "retry")
+                    throw new BroadcastClientError("Broadcast replay fields are not supported", false);
+            }
+            while (live()) {
+                const chunk = await abortable(reader.read(), abort.signal);
+                if (!live() || chunk.done)
+                    break;
+                arm(broadcastLimits.heartbeatMs * 2 + 5_000);
+                if (chunk.value.byteLength > broadcastLimits.bufferedBytes)
+                    throw new BroadcastClientError("Broadcast stream exceeds the buffer limit", false);
+                try {
+                    buffer += decoder.decode(chunk.value, { stream: true });
+                }
+                catch {
+                    throw new BroadcastClientError("Invalid broadcast text encoding", false);
+                }
+                if (new TextEncoder().encode(buffer).byteLength >
+                    broadcastLimits.bufferedBytes)
+                    throw new BroadcastClientError("Broadcast stream exceeds the buffer limit", false);
+                for (;;) {
+                    const match = /\r\n|\r|\n/.exec(buffer);
+                    if (!match)
+                        break;
+                    if (match[0] === "\r" && match.index === buffer.length - 1)
+                        break;
+                    const value = buffer.slice(0, match.index);
+                    buffer = buffer.slice(match.index + match[0].length);
+                    await line(value);
+                    if (!live())
+                        break;
+                }
+            }
+        }
+        catch (error) {
+            if (current === generation &&
+                !closed &&
+                error instanceof BroadcastClientError &&
+                !error.retryable) {
+                terminal = true;
+                for (const entry of included)
+                    fail(entry, error);
+            }
+            else if (current === generation &&
+                !closed &&
+                (error instanceof BroadcastValidationError ||
+                    (reading && !abort.signal.aborted && error instanceof SyntaxError))) {
+                terminal = true;
+                for (const entry of included)
+                    fail(entry, new BroadcastClientError("Invalid broadcast payload", false));
+            }
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (lifetime !== undefined)
+                clearTimeout(lifetime);
+            if (readiness !== undefined)
+                clearTimeout(readiness);
+            abort.abort();
+            void reader?.cancel().catch(() => undefined);
+            if (current === generation && !closed) {
+                controller = undefined;
+                if (!terminal)
+                    for (const entry of included) {
+                        if (!entry.blocked && entry.nextAttemptAt <= Date.now())
+                            fail(entry, new BroadcastClientError("Broadcast connection interrupted", true));
+                    }
+                scheduleRetry();
+            }
+        }
+    }
+    function wake() {
+        if (typeof document !== "undefined" &&
+            document.visibilityState === "hidden")
+            return;
+        restart();
+    }
+    if (typeof window !== "undefined")
+        window.addEventListener("online", wake);
+    if (typeof document !== "undefined")
+        document.addEventListener("visibilitychange", wake);
+    return {
+        subscribe(channel, subscriptionOptions) {
+            if (closed)
+                throw new BroadcastClientError("Broadcast client is closed", false);
+            let entry;
+            let invalid = false;
+            const observer = {
+                ...subscriptionOptions,
+                active: true,
+                validation: new AbortController(),
+                onEvent: (event) => subscriptionOptions.onEvent(event),
+            };
+            observers.add(observer);
+            const validationTimeout = setTimeout(() => observer.validation.abort(), broadcastLimits.readyTimeoutMs);
+            void abortable(parseChannelParams(channel, subscriptionOptions.params), observer.validation.signal)
+                .then((params) => {
+                if (!observer.active || closed)
+                    return;
+                const key = channelKey(channel.name, params);
+                entry = entries.get(key);
+                if (!entry) {
+                    if (entries.size >= broadcastLimits.subscriptions)
+                        throw new BroadcastClientError("Broadcast client supports at most 20 distinct subscriptions", false);
+                    entry = {
+                        id: String(++nextId),
+                        key,
+                        channel,
+                        params,
+                        observers: new Set(),
+                        blocked: false,
+                        ready: false,
+                        failures: 0,
+                        nextAttemptAt: 0,
+                    };
+                    entries.set(key, entry);
+                    entry.observers.add(observer);
+                    restart();
+                }
+                else {
+                    if (entry.channel !== channel)
+                        throw new BroadcastClientError(`Conflicting definitions for channel ${channel.name}`, false);
+                    entry.observers.add(observer);
+                    invoke(observer, () => observer.onStatusChange?.(status(entry)));
+                    if (entry.ready)
+                        invoke(observer, observer.onSync);
+                }
+            })
+                .catch((error) => {
+                invalid = true;
+                report(observer, error);
+                invoke(observer, () => observer.onStatusChange?.("blocked"));
+            })
+                .finally(() => clearTimeout(validationTimeout));
+            return {
+                getStatus: () => !observer.active || closed
+                    ? "closed"
+                    : invalid
+                        ? "blocked"
+                        : status(entry),
+                unsubscribe() {
+                    if (!observer.active)
+                        return;
+                    observer.active = false;
+                    observer.validation.abort();
+                    observers.delete(observer);
+                    entry?.observers.delete(observer);
+                    if (entry &&
+                        !entry.observers.size &&
+                        entries.get(entry.key) === entry) {
+                        entries.delete(entry.key);
+                        restart();
+                    }
+                },
+            };
+        },
+        getRequestHeaders: () => ({ "X-Beignet-Broadcast-Client": clientId }),
+        getStatus: () => status(),
+        resume() {
+            for (const entry of entries.values()) {
+                entry.blocked = false;
+                entry.nextAttemptAt = 0;
+                entry.failures = 0;
+            }
+            restart();
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            generation++;
+            controller?.abort();
+            clearRetry();
+            if (typeof window !== "undefined")
+                window.removeEventListener("online", wake);
+            if (typeof document !== "undefined")
+                document.removeEventListener("visibilitychange", wake);
+            for (const observer of observers) {
+                invoke(observer, () => observer.onStatusChange?.("closed"));
+                observer.active = false;
+                observer.validation.abort();
+            }
+            observers.clear();
+            entries.clear();
+        },
+    };
+}
+//# sourceMappingURL=client.js.map