gemi 0.122.0 → 0.124.0

package/dist/services/broadcast/SocketHub.d.ts

@@ -0,0 +1,201 @@
+import type { Server, ServerWebSocket, WebSocketHandler } from "bun";
+import type { Application } from "../../foundation/Application";
+import { type CarriedContext } from "../../http/requestContext";
+import type { BroadcastRevocation } from "./BroadcastDriver";
+import type { BroadcastManager } from "./BroadcastManager";
+/** What the hub keeps on each of its sockets (`ws.data`). */
+export interface GemiSocketData {
+    /** Marks a broadcast socket, as opposed to the dev server's HMR relay. */
+    readonly gemiSocket: true;
+    /** The hub that accepted it. After a dev reload that may not be the current one. */
+    readonly hub: SocketHub;
+    readonly socketId: string;
+    readonly tag: string;
+    /** The upgrade request, kept to rebuild a request context for every `sub`. */
+    readonly request: {
+        url: string;
+        headers: [string, string][];
+    };
+    /** What the global middleware resolved for the upgrade: its user. */
+    readonly carried: CarriedContext | null;
+    /** The signed-in user's id at the upgrade, for limits and `revoke({ user })`. */
+    readonly userId: string | null;
+    readonly ip: string | null;
+    /** Subscription id → its topic, `null` while it is being authorized. */
+    readonly subs: Map<string, Subscription>;
+    /** Topic → how many of this socket's subscriptions are on it. */
+    readonly topics: Map<string, number>;
+    rate: {
+        windowStart: number;
+        subs: number;
+        pings: number;
+    };
+    /**
+     * The process, IP and user connection counts this socket holds. Taken
+     * before the upgrade's first `await`, so concurrent upgrades cannot
+     * overshoot the caps, and given back exactly once.
+     */
+    reservation: Reservation | null;
+    /** The hub has closed it (backpressure, revoke, bye); its close is on the way. */
+    closing: boolean;
+    closed: boolean;
+}
+interface Subscription {
+    pattern: string;
+    params: Record<string, string | number>;
+    topic: string | null;
+}
+interface Reservation {
+    ip: string | null;
+    userId: string | null;
+}
+type GemiSocket = ServerWebSocket<GemiSocketData>;
+/**
+ * The WebSocket side of broadcasting, one per HTTP server process: accepts
+ * upgrades on the configured path, speaks the `gemi.v1` protocol (see
+ * `protocol.ts`), authorizes every subscription through the app's
+ * `ChannelRouter`, and delivers what the driver hands it with
+ * `server.publish`.
+ *
+ * Nothing here keeps a queue or a log. A socket that falls behind is closed
+ * (`1013`), one whose user signs out is closed (`4001`), and a server that
+ * stops says `bye` (`1012`); in every case the client reconnects and
+ * refetches what it shows.
+ */
+export declare class SocketHub {
+    private readonly manager;
+    private readonly application;
+    static token: string;
+    private server;
+    private readonly sockets;
+    private readonly byTopic;
+    private readonly topicReady;
+    private readonly perIp;
+    private readonly perUser;
+    /** Sockets held or being upgraded: the process cap's count. */
+    private connections;
+    /** Bumped by every topic revocation; see `revokedAt`. */
+    private revocationSeq;
+    /** Topic → the `revocationSeq` of its last revocation. */
+    private readonly revokedAt;
+    private closing;
+    /** Resolves once every socket `shutdown` closed is gone, or was cut. */
+    private closed;
+    private onAllClosed;
+    private startPromise;
+    constructor(manager: BroadcastManager, application: Application);
+    private get config();
+    /** Whether `req` is for the socket endpoint (an upgrade or not). */
+    matches(req: Request): boolean;
+    /** Sockets open on this process. */
+    get size(): number;
+    /**
+     * Starts delivering: the driver's frames for this process go out with
+     * `server.publish`. Call once the server is listening.
+     */
+    start(server: Server<any>): Promise<void>;
+    /**
+     * Answers a request for the socket endpoint: upgrades it, or refuses it
+     * with a status saying why. `undefined` once Bun has taken it over.
+     */
+    upgrade(req: Request, server: Server<any>): Promise<Response | undefined>;
+    private tryUpgrade;
+    private authenticate;
+    /**
+     * `true`, or why the upgrade is refused. A browser always sends `Origin` on
+     * a WebSocket upgrade, and cookies ride along with it whatever the page
+     * that opened it, so an upgrade carrying cookies must come from an allowed
+     * origin and one without `Origin` is refused. A native client sends its
+     * token in a header and no cookies, and may leave `Origin` out.
+     */
+    private checkOrigin;
+    /** Whether `origin` may open a socket. */
+    originAllowed(origin: string, req: Request): boolean;
+    private reserve;
+    private release;
+    /** `Bun.serve`'s `websocket` option. */
+    get websocket(): WebSocketHandler<GemiSocketData>;
+    /** The server-wide socket settings, also for a handler shared with HMR in dev. */
+    socketOptions(): {
+        readonly maxPayloadLength: number;
+        readonly idleTimeout: number;
+        readonly backpressureLimit: number;
+        readonly closeOnBackpressureLimit: true;
+        readonly sendPings: true;
+        readonly perMessageDeflate: false;
+    };
+    onOpen(ws: GemiSocket): void;
+    onMessage(ws: GemiSocket, message: string | Buffer): void;
+    onClose(ws: GemiSocket): void;
+    private rateWindow;
+    /**
+     * Counts a `sub`. Only `sub` frames count: an `unsub` costs the server
+     * nothing to speak of, and counting it would charge a component's every
+     * mount and unmount twice.
+     */
+    private countSub;
+    /** `false` when the socket was closed for pinging too often. */
+    private countPing;
+    private subscribe;
+    /** Runs the channel's authorization for `sub`, as the socket's upgrade request. */
+    private authorize;
+    private unsubscribeFrame;
+    /** Puts `ws` on `topic`, and resolves once the driver delivers the topic here. */
+    private join;
+    private leave;
+    /**
+     * The driver's delivery for this process. A socket already over the
+     * backpressure limit is closed first (1013): it would only fall further
+     * behind, and its client recovers by reconnecting and refetching.
+     */
+    deliver(topic: string, frame: string): void;
+    /**
+     * The driver may have lost frames, revocations included (a Redis
+     * subscriber that reconnected). Clients are told to resync, and every
+     * subscription is authorized again, as after `revoke({ channel })`, so
+     * one whose access a missed revocation ended is denied. Spread over
+     * `GAP_REAUTHORIZE_SPREAD_MS`, so a Redis blip does not send every
+     * authorization to the database at once.
+     */
+    private onGap;
+    /** Applies a revocation that reached this process. */
+    applyRevocation(revocation: BroadcastRevocation): void;
+    /**
+     * After `revoke({ channel })`: every subscription `ws` has on `topic` is
+     * authorized again, as the socket's upgrade request. The ones refused are
+     * denied with `revoked`; the others stay, and get a fresh `subscribed` so
+     * the client resyncs whatever was published while the topic was paused.
+     * The socket receives nothing on the topic until the answers are in.
+     */
+    private reauthorize;
+    private sendAll;
+    /**
+     * Stops accepting sockets and says `bye` to every open one, with a
+     * jittered `retryAfter` (1–5 s) so a restart's reconnects do not arrive at
+     * once, then closes them (1012). Sockets that have not closed after
+     * `terminateAfterMs` are cut. Idempotent.
+     *
+     * Resolves once every socket has closed, or at `terminateAfterMs` when the
+     * rest were cut: by the hub's own count, which the drain waits on instead
+     * of Bun's (on a loaded CI runner, Bun's graceful `stop()` was seen to wait
+     * on terminated sockets for good).
+     */
+    shutdown(options?: {
+        terminateAfterMs?: number;
+    }): Promise<void>;
+    /** Whether `shutdown` ran. */
+    get isClosing(): boolean;
+    private sayBye;
+    /** In the application's scope, as a request is: facades resolve from it. */
+    private run;
+}
+/**
+ * Whether an `allowedOrigins` entry (or `APP_URL` / `HOST_NAME`) admits
+ * `url`. An entry is an origin (`https://app.example.com`), a bare host
+ * (`app.example.com`), or a wildcard for the subdomains of a host
+ * (`*.example.com`, `https://*.example.com`), which does not admit the host
+ * itself.
+ */
+export declare function originMatches(allowed: string, url: URL): boolean;
+export {};
+//# sourceMappingURL=SocketHub.d.ts.map

package/dist/services/broadcast/SocketHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SocketHub.d.ts","sourceRoot":"","sources":["../../../services/broadcast/SocketHub.ts"],"names":[],"mappings":"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"}

package/dist/services/broadcast/brand.d.ts

@@ -0,0 +1,16 @@
+import type { ChannelTarget } from "./channels";
+/**
+ * Marks a `BroadcastEvent` instance. A symbol in the global registry rather
+ * than `instanceof`, for the reason `Event` gives: a production build can hold
+ * two copies of an event class, and `instanceof` would tell them apart.
+ */
+export declare const BROADCAST_EVENT: unique symbol;
+/** What `EventManager` needs of an event to broadcast it. */
+export interface BroadcastableEvent {
+    broadcastOn(): ChannelTarget | string | ReadonlyArray<ChannelTarget | string>;
+    broadcastAs(): string;
+    broadcastWith(): unknown;
+}
+/** Whether `event` is a `BroadcastEvent`, from any copy of gemi. */
+export declare function isBroadcastEvent(event: unknown): event is BroadcastableEvent;
+//# sourceMappingURL=brand.d.ts.map

package/dist/services/broadcast/brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../../services/broadcast/brand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD;;;;GAIG;AACH,eAAO,MAAM,eAAe,eAAoC,CAAC;AAEjE,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,WAAW,IAAI,aAAa,GAAG,MAAM,GAAG,aAAa,CAAC,aAAa,GAAG,MAAM,CAAC,CAAC;IAC9E,WAAW,IAAI,MAAM,CAAC;IACtB,aAAa,IAAI,OAAO,CAAC;CAC1B;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAM5E"}

package/dist/services/broadcast/channels.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Channel names: patterns, the topics they build, and the checks both go
+ * through. Shared by the `Broadcast` facade (which builds the topic an emit
+ * goes to), `ChannelRouter` (which builds the topic a socket may join) and the
+ * fake (which matches a pattern against recorded topics), so the three can
+ * never disagree on what `site.:siteId` with `{ siteId: "abc" }` is called.
+ *
+ * A pattern is dot-separated segments, each either a literal (`site`) or a
+ * param (`:siteId`). A topic is the same with every param filled in:
+ * `site.abc123`. Param values are restricted to `[A-Za-z0-9_-]`, so a value
+ * can never contain a dot and add a segment, and a topic can always be read
+ * back as exactly one pattern's.
+ */
+/** The longest topic, in characters. */
+export declare const MAX_TOPIC_LENGTH = 255;
+/** The longest event name, in characters. */
+export declare const MAX_EVENT_NAME_LENGTH = 64;
+/** The names of a pattern's params: `"site.:siteId"` → `"siteId"`. */
+export type ChannelParamNames<P extends string> = P extends `${infer Head}.${infer Rest}` ? SegmentParam<Head> | ChannelParamNames<Rest> : SegmentParam<P>;
+type SegmentParam<S extends string> = S extends `:${infer Name}` ? Name : never;
+/** The params a pattern takes: `"site.:siteId"` → `{ siteId: string | number }`. */
+export type ChannelParams<P extends string> = {
+    [K in ChannelParamNames<P>]: string | number;
+};
+/**
+ * `[]` for a pattern without params (or a concrete topic), `[params]` for one
+ * with them, so `Broadcast.to("status")` and `Broadcast.to("site.:siteId",
+ * { siteId })` both type-check and `Broadcast.to("site.:siteId")` does not.
+ */
+export type ChannelParamsArgs<P extends string> = [ChannelParamNames<P>] extends [never] ? [params?: Record<string, never>] : [params: ChannelParams<P>];
+/**
+ * A resolved channel: the topic sockets subscribe to, and the pattern it came
+ * from when it was built from one. What `BroadcastEvent.channel()` returns and
+ * `Broadcast.to()` accepts.
+ */
+export interface ChannelTarget {
+    readonly topic: string;
+    readonly pattern?: string;
+}
+/** A pattern, topic or param was refused. The message says which and why. */
+export declare class InvalidChannelError extends Error {
+    constructor(message: string);
+}
+/** Whether `value` is a `ChannelTarget` rather than a pattern string. */
+export declare function isChannelTarget(value: unknown): value is ChannelTarget;
+/** The segments of a pattern, checked. Throws `InvalidChannelError`. */
+export declare function parsePattern(pattern: string): string[];
+/** The param names of a pattern, in order. */
+export declare function patternParams(pattern: string): string[];
+/**
+ * The topic `pattern` names with `params` filled in. Every param must be
+ * given, and nothing else: a missing one, an extra one, or a value outside
+ * `[A-Za-z0-9_-]` throws `InvalidChannelError`, so a client can never steer a
+ * subscription onto a topic its pattern does not describe.
+ */
+export declare function buildTopic(pattern: string, params?: Record<string, unknown>): string;
+/** Checks a concrete topic (no params). Throws `InvalidChannelError`. */
+export declare function assertTopic(topic: string): string;
+/** Checks an event name. Throws `InvalidChannelError`. */
+export declare function assertEventName(event: string): string;
+/**
+ * Whether `topic` is one `pattern` builds. A pattern without params matches
+ * only itself, except `"user"`, which also matches every `user.<id>`: that is
+ * the topic the router's `user` channel resolves to.
+ */
+export declare function topicMatches(pattern: string, topic: string): boolean;
+/**
+ * The channel `ChannelRouter` resolves from the session rather than from
+ * params: a socket that subscribes to `"user"` joins `user.<its user's id>`.
+ */
+export declare const USER_CHANNEL = "user";
+/** The topic of a user's own channel. */
+export declare function userTopic(user: {
+    id: unknown;
+} | string | number): string;
+export {};
+//# sourceMappingURL=channels.d.ts.map

package/dist/services/broadcast/channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../../services/broadcast/channels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,6CAA6C;AAC7C,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAOxC,sEAAsE;AACtE,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,IAAI,MAAM,IAAI,EAAE,GACrF,YAAY,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAC5C,YAAY,CAAC,CAAC,CAAC,CAAC;AAEpB,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,IAAI,EAAE,GAAG,IAAI,GAAG,KAAK,CAAC;AAEhF,oFAAoF;AACpF,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI;KAC3C,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,MAAM;CAC7C,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACpF,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAChC,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/B;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,6EAA6E;AAC7E,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAMtE;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAqCtD;AAED,8CAA8C;AAC9C,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAIvD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAkCxF;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASjD;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAarD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAYpE;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC,yCAAyC;AACzC,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAGzE"}

package/dist/services/broadcast/config.d.ts

@@ -0,0 +1,106 @@
+import type { Application } from "../../foundation/Application";
+import type { BroadcastDriver } from "./BroadcastDriver";
+import type { RedisBroadcastDriverOptions } from "./RedisBroadcastDriver";
+export interface BroadcastConfig {
+    /**
+     * Which processes see an emit: `"memory"`, `"redis"`, a `BroadcastDriver`,
+     * or a function returning one, called once with the application.
+     *
+     * `"memory"` is the default and reaches the sockets of **this process
+     * only**: right for one instance whose web processes also run the jobs,
+     * wrong for several replicas or a separate `gemi queue:work` worker. See
+     * `MemoryBroadcastDriver`.
+     *
+     * `"redis"` reaches every process of the app through Redis pub/sub (see
+     * `redis` below and `RedisBroadcastDriver`). It needs `SECRET` set, the
+     * same on every instance; the boot fails without it.
+     */
+    driver?: "memory" | "redis" | BroadcastDriver | ((application: Application) => BroadcastDriver);
+    /**
+     * The `"redis"` driver's settings. The connection defaults to the app's
+     * own (`app/config/redis.ts`: `url`, else `REDIS_URL`, and `options`);
+     * set `url` / `options` here to use another server. `prefix` (default
+     * `"gemi:bc:"`) names the Redis channels: give each app sharing one Redis
+     * its own.
+     */
+    redis?: Pick<RedisBroadcastDriverOptions, "url" | "options" | "prefix" | "subscribeTimeoutMs" | "healthCheckMs">;
+    /**
+     * The largest event frame, in bytes, JSON-encoded with its topic and name.
+     * A bigger emit throws `BroadcastPayloadTooLargeError` at the call site.
+     * Default `16384` (16 KB). Send ids and a change hint, and let the client
+     * fetch the data over HTTP.
+     */
+    maxEventBytes?: number;
+    /**
+     * Frames above this size log a warning, once per event name. Default
+     * `4096` (4 KB). `false` turns the warning off.
+     */
+    warnEventBytes?: number | false;
+    /**
+     * The WebSocket endpoint, on the app's own origin. Default
+     * `"/__gemi/socket"`. Change it on the client too:
+     * `init(RootLayout, { realtime: { path } })`.
+     */
+    path?: string;
+    /**
+     * Origins allowed to open a socket, besides the app's own (the request's
+     * own host, and `APP_URL` / `HOST_NAME`). An entry is an origin
+     * (`"https://app.example.com"`), a bare host (`"app.example.com"`), or a
+     * wildcard for a host's subdomains (`"*.example.com"`,
+     * `"https://*.example.com"`), which does not admit the host itself.
+     *
+     * Subdomains are never allowed by default, `route.domains` ones included:
+     * a tenant's subdomain is same-site with the app, so the app's cookies ride
+     * along with its upgrade, and a WebSocket has no CORS. List a wildcard only
+     * for subdomains whose pages you trust. A cookie-carrying upgrade without
+     * an `Origin` header is refused, and so is any upgrade from an origin not
+     * allowed.
+     */
+    allowedOrigins?: string[];
+    /** Open sockets per process. Upgrades past it get a `503`. Default `10000`. */
+    maxConnectionsPerProcess?: number;
+    /**
+     * Open sockets per client IP, per process. Default `100`. The address is
+     * the TCP peer unless `GEMI_TRUST_PROXY` says which `X-Forwarded-For` entry
+     * to believe: behind a proxy without it, every client shares the proxy's
+     * address and this caps the whole app per process (the server warns at
+     * boot).
+     */
+    maxConnectionsPerIp?: number;
+    /** Open sockets per signed-in user, per process. Default `50`. */
+    maxConnectionsPerUser?: number;
+    /** Subscriptions per socket. Past it a `sub` is denied with `limit`. Default `50`. */
+    maxChannelsPerSocket?: number;
+    /** The largest frame a client may send, in bytes. Default `16384`. */
+    maxInboundMessageBytes?: number;
+    /**
+     * How many bytes may queue up for one socket before it is closed with
+     * `1013`; the client reconnects and refetches. No queue is kept per
+     * socket beyond this. Default `1048576` (1 MB).
+     */
+    backpressureLimit?: number;
+    /**
+     * Seconds without a frame or a pong before Bun closes a socket. Bun pings
+     * idle sockets on its own. Default `120`.
+     */
+    idleTimeout?: number;
+    /**
+     * How often the client pings, in ms, sent to it in `hello`. A client that
+     * hears nothing for twice this reconnects, so a connection a proxy dropped
+     * silently is noticed within about a minute. Default `25000`.
+     */
+    heartbeatMs?: number;
+    /**
+     * `sub` frames a socket may send per window (an `unsub` is not counted).
+     * Past it a `sub` is denied with `rate_limited`, which the client retries
+     * on the same socket after a few seconds; at twice it the socket is closed
+     * with `1008`. Default `{ limit: 300, windowMs: 60000 }`.
+     */
+    subscribeRate?: {
+        limit: number;
+        windowMs: number;
+    };
+}
+export declare function defineBroadcastConfig(config: BroadcastConfig): BroadcastConfig;
+export declare function broadcastConfigDefaults(): Required<BroadcastConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/services/broadcast/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../services/broadcast/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAI1E,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,eAAe,GAAG,CAAC,CAAC,WAAW,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC;IAEhG;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,IAAI,CACV,2BAA2B,EAC3B,KAAK,GAAG,SAAS,GAAG,QAAQ,GAAG,oBAAoB,GAAG,eAAe,CACtE,CAAC;IAEF;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAEhC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B,+EAA+E;IAC/E,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,sFAAsF;IACtF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,sEAAsE;IACtE,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,aAAa,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAE9E;AAED,wBAAgB,uBAAuB,IAAI,QAAQ,CAAC,eAAe,CAAC,CAkBnE"}

package/dist/services/broadcast/protocol.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The `gemi.v1` WebSocket protocol, shared by the server transport
+ * (`SocketHub`) and the browser client (`gemi/client`'s connection manager).
+ * Types and constants only: this module is imported by the browser bundle, so
+ * it must never import a server module.
+ *
+ * Every frame is a JSON text frame. Binary frames are refused.
+ *
+ * From the client:
+ *
+ * - `{op:"sub", id, ch, p?}`: subscribe `id` (chosen by the client, unique per
+ *   socket) to the channel pattern `ch` with params `p`. The server builds
+ *   the topic and authorizes it.
+ * - `{op:"unsub", id}`
+ * - `{op:"ping"}`: answered with `pong`. The client sends one every
+ *   `heartbeatMs` and reconnects when it hears nothing for twice that.
+ *
+ * From the server:
+ *
+ * - `{op:"hello", socketId, tag, heartbeatMs}`: the first frame. `socketId`
+ *   goes in the `X-Gemi-Socket` header of the client's own requests (for
+ *   `Broadcast.toOthers`); it is never shown to anyone else. `tag` is what
+ *   an event frame's `x` carries when it skips this socket.
+ * - `{op:"subscribed", id, t}`: `id` joined topic `t`. Sent only once this
+ *   process receives the topic's events, so the resync the client runs on it
+ *   cannot miss one.
+ * - `{op:"denied", id, code}`: `id` was refused, or later revoked.
+ * - `{op:"ev", t, ev, d?, x?}`: an event on topic `t`. Dropped by the socket
+ *   whose `tag` is `x`.
+ * - `{op:"gap"}`: events may have been lost for this socket; resync all.
+ * - `{op:"pong"}`
+ * - `{op:"bye", code, retryAfter}`: the server is going away (a restart).
+ *   Reconnect after `retryAfter` ms.
+ */
+/** The WebSocket subprotocol. */
+export declare const BROADCAST_PROTOCOL = "gemi.v1";
+/** The default endpoint, `defineBroadcastConfig({ path })`. */
+export declare const DEFAULT_SOCKET_PATH = "/__gemi/socket";
+/** The request header a client sends its socket id in, for `toOthers`. */
+export declare const SOCKET_ID_HEADER = "x-gemi-socket";
+/** What a subscription id may look like. */
+export declare const SUBSCRIPTION_ID: RegExp;
+/**
+ * Close codes the server uses. 1012 and 1013 are the standard "restart" and
+ * "try again later"; the 4xxx ones are gemi's own.
+ */
+export declare const CloseCode: {
+    /** The client went away (tab closed, socket released). */
+    readonly Normal: 1000;
+    /** A frame that was not JSON text, or not a known op. */
+    readonly UnsupportedData: 1003;
+    /** Too many frames, or a frame over the size limit. */
+    readonly PolicyViolation: 1008;
+    /** The server is restarting; `bye` said when to come back. */
+    readonly Restart: 1012;
+    /** The socket fell too far behind; reconnect and resync. */
+    readonly TryAgainLater: 1013;
+    /** The socket's user was signed out or its access revoked. */
+    readonly Revoked: 4001;
+};
+/** Why a subscription was refused. */
+export type DeniedCode = 
+/** No channel with that pattern. Permanent. */
+"unknown_channel"
+/** Missing, extra or malformed params. Permanent. */
+ | "invalid_params"
+/** The channel's authorization said no. */
+ | "denied"
+/** Authorization failed (a session store outage, a bug). Retryable. */
+ | "error"
+/** The socket has `maxChannelsPerSocket` subscriptions already. */
+ | "limit"
+/** Too many `sub`/`unsub` frames; retry later. */
+ | "rate_limited"
+/** The subscription was revoked by `Broadcast.revoke`. */
+ | "revoked"
+/** The frame was malformed, or the id is already in use. */
+ | "invalid";
+export type ClientFrame = {
+    op: "sub";
+    id: string;
+    ch: string;
+    p?: Record<string, string | number>;
+} | {
+    op: "unsub";
+    id: string;
+} | {
+    op: "ping";
+};
+export type ServerFrame = {
+    op: "hello";
+    socketId: string;
+    tag: string;
+    heartbeatMs: number;
+} | {
+    op: "subscribed";
+    id: string;
+    t: string;
+} | {
+    op: "denied";
+    id: string;
+    code: DeniedCode;
+} | {
+    op: "ev";
+    t: string;
+    ev: string;
+    d?: unknown;
+    x?: string;
+} | {
+    op: "gap";
+} | {
+    op: "pong";
+} | {
+    op: "bye";
+    code: number;
+    retryAfter: number;
+};
+/**
+ * Whether a refusal is final for this socket's session: resubscribing will
+ * get the same answer, so the client does not retry it on its own.
+ */
+export declare function isPermanentDenial(code: DeniedCode): boolean;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/services/broadcast/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../services/broadcast/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,iCAAiC;AACjC,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAE5C,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,kBAAkB,CAAC;AAEhD,4CAA4C;AAC5C,eAAO,MAAM,eAAe,QAA0B,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,SAAS;IACpB,0DAA0D;;IAE1D,yDAAyD;;IAEzD,uDAAuD;;IAEvD,8DAA8D;;IAE9D,4DAA4D;;IAE5D,8DAA8D;;CAEtD,CAAC;AAEX,sCAAsC;AACtC,MAAM,MAAM,UAAU;AACpB,+CAA+C;AAC7C,iBAAiB;AACnB,qDAAqD;GACnD,gBAAgB;AAClB,2CAA2C;GACzC,QAAQ;AACV,uEAAuE;GACrE,OAAO;AACT,mEAAmE;GACjE,OAAO;AACT,kDAAkD;GAChD,cAAc;AAChB,0DAA0D;GACxD,SAAS;AACX,4DAA4D;GAC1D,SAAS,CAAC;AAEd,MAAM,MAAM,WAAW,GACnB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;CAAE,GAC1E;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC3B;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnB,MAAM,MAAM,WAAW,GACnB;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACnE;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GAC9C;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,GACb;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GACd;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE3D"}

package/dist/services/broadcast/socketTag.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The tag an event frame's `x` names a socket by: a keyed hash of its id.
+ *
+ * Subscribers see `x`, so it must not be the id: the id is what a client
+ * sends in `X-Gemi-Socket` to have its own emits skip it, and a subscriber
+ * who learned another's id could make the server skip that socket instead.
+ * The tag cannot be turned back into the id.
+ *
+ * Keyed with a key derived from `SECRET`, so every instance of the app
+ * computes the same tag for an id (the Redis driver carries frames between
+ * them). Without `SECRET` the key is random per process, which is right for
+ * one instance and wrong for several; the Redis driver needs `SECRET`.
+ */
+export declare function socketTag(socketId: string): string;
+/** A new socket id: 22 url-safe characters, 128 random bits. */
+export declare function newSocketId(): string;
+//# sourceMappingURL=socketTag.d.ts.map

package/dist/services/broadcast/socketTag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socketTag.d.ts","sourceRoot":"","sources":["../../../services/broadcast/socketTag.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElD;AAcD,gEAAgE;AAChE,wBAAgB,WAAW,IAAI,MAAM,CAEpC"}

package/dist/services/broadcast/types.d.ts

@@ -0,0 +1,27 @@
+import type { BroadcastRPC } from "../../client/rpc";
+/** Any event map: what a channel the app has not typed accepts. */
+export type AnyBroadcastEvents = Record<string, unknown>;
+/**
+ * The events a pattern's channel carries, from the app's generated
+ * `BroadcastRPC` (its `ChannelRouter`). A pattern the router does not declare,
+ * a concrete topic, or a channel without declared events takes any event.
+ */
+export type BroadcastEventsFor<P extends string> = P extends keyof BroadcastRPC ? BroadcastRPC[P] extends {
+    events: infer E extends Record<string, unknown>;
+} ? E : AnyBroadcastEvents : AnyBroadcastEvents;
+/** `emit`'s data argument: optional when the event's payload may be undefined. */
+export type BroadcastDataArgs<T> = undefined extends T ? [data?: T] : [data: T];
+/** One emit, as the fake records it. */
+export interface SentBroadcast {
+    /** The concrete topic, e.g. `site.abc123`. */
+    topic: string;
+    /** The pattern the topic was built from, when it was built from one. */
+    pattern?: string;
+    /** The event name. */
+    event: string;
+    /** The payload, as emitted. */
+    data: unknown;
+    /** The socket `toOthers` skipped, if any. */
+    except?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/broadcast/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../services/broadcast/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,mEAAmE;AACnE,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEzD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,MAAM,YAAY,GAC3E,YAAY,CAAC,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACzE,CAAC,GACD,kBAAkB,GACpB,kBAAkB,CAAC;AAEvB,kFAAkF;AAClF,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,SAAS,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAEhF,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/services/broadcast/wire.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The frames an emit becomes. Encoded once per emit and handed to every
+ * socket on the topic unchanged (`server.publish`), so a frame names its
+ * topic and the client maps the topic to its own subscriptions.
+ *
+ * ```json
+ * {"op":"ev","t":"site.abc123","ev":"changed","d":{"pages":["/about"]},"x":"<socket id>"}
+ * ```
+ *
+ * `d` is left out when the emit carried no data. `x` is set by an emit made
+ * with `Broadcast.toOthers(...)`: one frame goes to every process and every
+ * socket, so the socket it names drops it itself.
+ *
+ * `x` is the skipped socket's *tag*, a keyed hash of its id (`socketTag`),
+ * never the id itself. Every subscriber on the topic sees `x`; had it been
+ * the id, any of them could have sent it in its own `X-Gemi-Socket` header
+ * and made the server skip the victim for that client's emits. The id is
+ * only ever in the `hello` the socket's own client receives.
+ */
+export interface BroadcastEventFrame {
+    op: "ev";
+    /** The topic, e.g. `site.abc123`. */
+    t: string;
+    /** The event name. */
+    ev: string;
+    /** The payload, when there is one. */
+    d?: unknown;
+    /** The tag of the socket that must ignore this frame. */
+    x?: string;
+}
+export { SOCKET_ID_HEADER } from "./protocol";
+/** Whether `value` has the shape of a socket id the transport hands out. */
+export declare function isSocketId(value: unknown): value is string;
+export declare function encodeEventFrame(topic: string, event: string, data: unknown, except?: string | null): string;
+//# sourceMappingURL=wire.d.ts.map

package/dist/services/broadcast/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../services/broadcast/wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,IAAI,CAAC;IACT,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,CAAC,CAAC,EAAE,OAAO,CAAC;IACZ,yDAAyD;IACzD,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAI9C,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE1D;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,EACb,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,MAAM,CAKR"}