@rlanz/socket 0.0.1-0 → 0.0.1-10

package/build/base_channel-DKmR3Z0l.d.ts

@@ -0,0 +1,476 @@
+import { WebSocket } from 'ws';
+import { IncomingMessage } from 'node:http';
+import { MiddlewareAsClass } from '@adonisjs/core/types/http';
+import { HttpContext } from '@adonisjs/core/http';
+import { TransportFactory } from '@boringnode/bus/types/main';
+import './shared_types-DE86M136.js';
+
+declare const PRESENCE_DATA_KEY = "__rlanzSocketPresence";
+type PresenceSocketData = Record<string, unknown> & {
+    [PRESENCE_DATA_KEY]?: Record<string, PresenceUser>;
+};
+interface PresenceUser {
+    id: string;
+    joinedAt: Date;
+    [key: string]: unknown;
+}
+interface PresenceData {
+    channel: string;
+    users: PresenceUser[];
+    count: number;
+}
+interface PresenceSocket {
+    id: string;
+    data: PresenceSocketData;
+}
+/**
+ * Tracks user presence in channels.
+ *
+ * channel -> socketId -> PresenceUser
+ */
+declare class PresenceManager {
+    #private;
+    /**
+     * Sets the socket fetcher used to build distributed snapshots.
+     */
+    setSocketFetcher(fetchSockets: ((channel: string) => Promise<PresenceSocket[]>) | null): void;
+    /**
+     * Adds a user to a channel.
+     */
+    join(channel: string, socket: PresenceSocket, member: PresenceInfo): PresenceUser;
+    /**
+     * Removes a user from a channel.
+     */
+    leave(channel: string, socket: PresenceSocket): void;
+    /**
+     * Removes a user from every channel.
+     * Returns the list of channels the user left.
+     */
+    leaveAll(socket: PresenceSocket): string[];
+    /**
+     * Gets presence data for a channel.
+     */
+    snapshot(channel: string): Promise<PresenceData>;
+    /**
+     * Gets the number of users in a channel.
+     */
+    count(channel: string): Promise<number>;
+    /**
+     * Checks whether a socket is locally present in a channel.
+     */
+    hasLocal(channel: string, socketId: string): boolean;
+    /**
+     * Gets the presence user retained for one local socket.
+     */
+    getLocalUser(channel: string, socketId: string): PresenceUser | undefined;
+    /**
+     * Lists every local channel where a socket is present.
+     */
+    getLocalChannelsForSocket(socketId: string): string[];
+    /**
+     * Lists sockets that are locally present in a channel.
+     */
+    getLocalSockets(channel: string): PresenceSocket[];
+}
+
+/**
+ * Duration can be specified as milliseconds or as a human-readable string.
+ */
+type Duration = number | string;
+
+interface SocketTransportConfig {
+    driver: TransportFactory;
+    channel?: string;
+    /**
+     * How long to wait for other instances to answer a presence snapshot request.
+     */
+    presenceTimeout?: Duration;
+    /**
+     * In-memory retry policy for transport publications that fail.
+     *
+     * The queue is enabled and limited to 1000 distinct messages by default.
+     * Set maxSize to null only when an unbounded queue is explicitly desired.
+     */
+    retryQueue?: SocketRetryQueueConfig;
+}
+interface SocketRetryQueueConfig {
+    enabled?: boolean;
+    removeDuplicates?: boolean;
+    maxSize?: number | null;
+    retryInterval?: Duration | false;
+}
+
+interface RawSocket {
+    id: string;
+    data: Record<string, unknown>;
+    connection: WebSocket;
+    request: IncomingMessage;
+    httpContext: HttpContext;
+}
+/**
+ * Socket exposed to channels after the HTTP upgrade.
+ */
+interface AuthenticatedSocket<User = unknown> {
+    /**
+     * Unique socket ID.
+     */
+    id: string;
+    /**
+     * Authenticated user resolved during the HTTP upgrade.
+     */
+    user: User | undefined;
+    /**
+     * Returns the authenticated user or throws a client-safe unauthorized error.
+     */
+    getUserOrFail(): User;
+    /**
+     * Emits an event to this socket.
+     */
+    emit(event: string, data: unknown): void;
+    /**
+     * Disconnects the socket.
+     */
+    disconnect(): void;
+    /**
+     * Raw WebSocket connection metadata.
+     */
+    raw: RawSocket;
+}
+/**
+ * Short-lived context for preparing and authenticating a WebSocket upgrade.
+ * Socket-lifetime mutable state belongs in AuthenticatedSocket.raw.data.
+ */
+interface SocketUpgradeContext {
+    httpContext: HttpContext;
+}
+type SocketAuthenticationResult<User = unknown> = User | false | null;
+type SocketAuthenticationHandler<User = unknown> = (ctx: SocketUpgradeContext) => SocketAuthenticationResult<User> | Promise<SocketAuthenticationResult<User>>;
+type SocketOriginValues = boolean | string | string[];
+type SocketOriginResolver = (origin: string, httpContext: HttpContext) => SocketOriginValues;
+/**
+ * AdonisJS HTTP middleware executed for the WebSocket upgrade request.
+ */
+type SocketHttpMiddleware = (() => Promise<{
+    default: MiddlewareAsClass;
+}>) | MiddlewareAsClass;
+/**
+ * Result of matching a channel.
+ */
+interface ChannelMatch {
+    channel: BaseChannelConstructor;
+    pattern: string;
+    params: Record<string, string>;
+}
+/**
+ * Channel options.
+ */
+interface ChannelOptions {
+    presence?: boolean;
+}
+/**
+ * Identity and channel-specific data returned for a presence member.
+ */
+interface PresenceInfo {
+    id: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * Presence member exposed to snapshots and channel hooks.
+ */
+interface PresenceMember {
+    id: string;
+    joinedAt?: never;
+    [key: string]: unknown;
+}
+/**
+ * Context passed to middlewares.
+ */
+interface MiddlewareContext<User = unknown> {
+    socket: AuthenticatedSocket<User>;
+    channel: string;
+    params: Record<string, string>;
+    presenceData?: Record<string, unknown> | PresenceData;
+    setPresenceData(data: Record<string, unknown> | PresenceData): void;
+}
+/**
+ * Middleware function.
+ */
+type MiddlewareFn<User = unknown> = (ctx: MiddlewareContext<User>, next: () => Promise<void>) => Promise<void>;
+/**
+ * Middleware class.
+ */
+interface MiddlewareClass<User = unknown> {
+    handle: MiddlewareFn<User>;
+}
+/**
+ * Constructor for a middleware resolved through the AdonisJS container.
+ */
+interface MiddlewareConstructor<User = unknown> {
+    new (...args: any[]): MiddlewareClass<User>;
+    readonly prototype: MiddlewareClass<User>;
+}
+/**
+ * Middleware, either a function, an instance, or a container-resolved class.
+ */
+type Middleware<User = unknown> = MiddlewareFn<User> | MiddlewareClass<User> | MiddlewareConstructor<User>;
+/**
+ * Package configuration.
+ */
+interface SocketConfig<User = unknown> {
+    websocket?: {
+        path?: string;
+        /**
+         * Browser origin policy for opening a WebSocket connection.
+         *
+         * Uses the same value shapes as the AdonisJS CORS `origin` option. A resolver
+         * receives the request origin and HTTP context and may return any static value.
+         * Same-origin requests are allowed by default when this option is not defined.
+         * Clients without an Origin header are always allowed.
+         */
+        origin?: SocketOriginValues | SocketOriginResolver;
+        /**
+         * HTTP middleware executed only for the WebSocket upgrade request.
+         *
+         * Use this to initialize request-scoped services such as session or auth before
+         * websocket.authenticate. Channel middleware should be declared on channel classes.
+         */
+        middleware?: SocketHttpMiddleware[];
+        authenticate?: SocketAuthenticationHandler<User>;
+        /**
+         * Sends a WebSocket ping every configured duration.
+         *
+         * When only pingTimeout is configured, the service uses a default 25s interval.
+         */
+        pingInterval?: Duration;
+        /**
+         * Terminates connections that do not answer a ping within the configured duration.
+         *
+         * When only pingInterval is configured, the service uses a default 5s timeout.
+         */
+        pingTimeout?: Duration;
+        /**
+         * Maximum inbound WebSocket message payload size in bytes.
+         */
+        maxPayload?: number;
+        /**
+         * Maximum unresolved non-ping protocol messages per socket.
+         */
+        maxQueuedMessages?: number;
+        /**
+         * Maximum inbound protocol messages accepted per rate limit interval.
+         */
+        maxMessagesPerInterval?: number;
+        /**
+         * Duration of the inbound protocol message rate limit window.
+         */
+        messageRateInterval?: Duration;
+        /**
+         * Maximum buffered outbound WebSocket bytes accepted before the service closes the socket.
+         */
+        maxBufferedAmount?: number;
+        /**
+         * Maximum serialized size of one outbound WebSocket protocol message in bytes.
+         */
+        maxOutboundPayload?: number;
+        /**
+         * Maximum number of active channel subscriptions retained by one socket.
+         */
+        maxSubscriptionsPerSocket?: number;
+        /**
+         * Maximum accepted channel name length in characters.
+         */
+        maxChannelNameLength?: number;
+        /**
+         * Maximum time spent waiting for socket handlers and subscription hooks during shutdown.
+         * Internal socket state is forcibly released after this deadline.
+         */
+        shutdownTimeout?: Duration;
+    };
+    /**
+     * Optional transport used to synchronize broadcasts between SocketService instances.
+     */
+    transport?: SocketTransportConfig | null;
+}
+type SocketServiceStatus = 'starting' | 'ready' | 'stopping' | 'stopped' | 'failed';
+interface SocketHealthSnapshot {
+    status: SocketServiceStatus;
+    ready: boolean;
+    connections: number;
+    channels: number;
+    lastError?: string;
+}
+/**
+ * Events emitted by the service.
+ */
+interface SocketEvents<User = unknown> {
+    connect: {
+        socket: AuthenticatedSocket<User>;
+    };
+    disconnect: {
+        socket: AuthenticatedSocket<User>;
+        reason: string;
+    };
+    subscribe: {
+        socket: AuthenticatedSocket<User>;
+        channel: string;
+    };
+    unsubscribe: {
+        socket: AuthenticatedSocket<User>;
+        channel: string;
+    };
+}
+
+interface ChannelBroadcaster {
+    to(channel: string): {
+        emit(event: string, data: unknown): void;
+        except(socketId: string): {
+            emit(event: string, data: unknown): void;
+        };
+    };
+}
+type ChannelMiddlewareRunner = <User>(middleware: MiddlewareConstructor<User>, ctx: MiddlewareContext<User>, next: () => Promise<void>) => Promise<void>;
+type ChannelMiddlewareRunnerFactory = () => ChannelMiddlewareRunner;
+/**
+ * Error whose message may intentionally be returned to a socket client.
+ */
+declare class SocketResponseError extends Error {
+}
+/**
+ * Abstract class used to define a channel.
+ *
+ * @example
+ * ```ts
+ * export default class ChatChannel extends BaseChannel {
+ *   static pattern = 'chat/:roomId'
+ *   static middlewares = [
+ *     async (ctx, next) => {
+ *       // Authorize access to the channel through middleware.
+ *       // if (!Room.isMember(ctx.params.roomId, ctx.socket.user.id)) throw new Error('Forbidden')
+ *       await next()
+ *     },
+ *   ]
+ * }
+ * ```
+ *
+ * @example With presence and decorated handlers
+ * ```ts
+ * import { onMessage } from '@rlanz/socket/decorators'
+ *
+ * export default class ChatChannel extends BaseChannel {
+ *   static pattern = 'chat/:roomId'
+ *   static options = { presence: true }
+ *
+ *   static middlewares = [
+ *     async (ctx, next) => {
+ *       if (!ctx.socket.user.isVerified) throw new Error('Not verified')
+ *       await next()
+ *     }
+ *   ]
+ *
+ *   @onMessage('chat:send')
+ *   async handleSend(socket: AuthenticatedSocket<User>, data: unknown) {
+ *     // Handle chat:send event
+ *   }
+ *
+ *   @onMessage('chat:typing')
+ *   async handleTyping(socket: AuthenticatedSocket<User>, data: unknown) {
+ *     // Handle chat:typing event
+ *   }
+ * }
+ * ```
+ */
+declare class BaseChannel<User = unknown, ServerEvents = Record<never, never>> {
+    /** Type-only server event declarations consumed by generated browser client types. */
+    readonly $serverEvents: ServerEvents;
+    /**
+     * URL-like channel pattern, for example: 'chat/:roomId'.
+     */
+    static pattern: string;
+    /**
+     * Channel options.
+     */
+    static options?: ChannelOptions;
+    /**
+     * Middlewares to run before subscription.
+     */
+    static middlewares?: Middleware<any>[];
+    /**
+     * Injected socket service.
+     */
+    protected socket: ChannelBroadcaster;
+    /**
+     * Full channel name, for example: 'chat/general'.
+     */
+    protected channelName: string;
+    /**
+     * Parameters extracted from the pattern, for example: { roomId: 'general' }.
+     */
+    protected params: Record<string, string>;
+    /**
+     * Injected presence manager when presence is enabled.
+     */
+    protected presence: PresenceManager;
+    /**
+     * Injects dependencies.
+     */
+    $setContext(socket: ChannelBroadcaster, channelName: string, params: Record<string, string>, presence?: PresenceManager): void;
+    /**
+     * Emits to every channel member.
+     */
+    protected broadcast<K extends keyof ServerEvents & string>(event: K, data: ServerEvents[K]): void;
+    /**
+     * Emits to every channel member except one socket.
+     */
+    protected broadcastExcept<K extends keyof ServerEvents & string>(socketId: string, event: K, data: ServerEvents[K]): void;
+    /**
+     * Runs the middleware chain.
+     *
+     * middleware[0] -> middleware[1] -> ... -> subscribe
+     */
+    $runMiddlewares(ctx: MiddlewareContext<User>, runClassMiddleware?: ChannelMiddlewareRunner): Promise<void>;
+    /**
+     * Returns member information for presence.
+     * Implement when options.presence = true.
+     */
+    getPresenceInfo?(socket: AuthenticatedSocket<User>): PresenceInfo;
+    /**
+     * Hook called when a socket joins the channel.
+     */
+    onJoin?(socket: AuthenticatedSocket<User>, ...params: string[]): Promise<void>;
+    /**
+     * Hook called when a socket leaves the channel.
+     */
+    onLeave?(socket: AuthenticatedSocket<User>, ...params: string[]): Promise<void>;
+    /**
+     * Hook called when a member joins a presence channel.
+     */
+    onMemberJoin?(socket: AuthenticatedSocket<User>, member: PresenceMember, ...params: string[]): Promise<void>;
+    /**
+     * Hook called when a member leaves a presence channel.
+     */
+    onMemberLeave?(socket: AuthenticatedSocket<User>, member: PresenceMember, ...params: string[]): Promise<void>;
+    /**
+     * Dispatches a message to the matching handler.
+     * Called by SocketService. Do not override.
+     */
+    $handleMessage(socket: AuthenticatedSocket<User>, event: string, data: unknown): Promise<unknown>;
+    /**
+     * Runs the generic join hook. ChannelSubscriptions owns subscription lifecycle.
+     */
+    $handleJoin(socket: AuthenticatedSocket<User>, ...params: string[]): Promise<void>;
+    /**
+     * Runs the generic leave hook. ChannelSubscriptions owns subscription lifecycle.
+     */
+    $handleLeave(socket: AuthenticatedSocket<User>, ...params: string[]): Promise<void>;
+    $getPresenceInfo(socket: AuthenticatedSocket<User>): PresenceInfo;
+}
+/** Constructor for any BaseChannel specialization, including container-injected dependencies. */
+interface BaseChannelConstructor {
+    new (...args: any[]): BaseChannel<any, any>;
+    readonly name: string;
+    pattern: string;
+    options?: ChannelOptions;
+    middlewares?: Middleware<any>[];
+}
+
+export { type AuthenticatedSocket as A, BaseChannel as B, type ChannelOptions as C, type Duration as D, type Middleware as M, PresenceManager as P, type RawSocket as R, type SocketAuthenticationHandler as S, type SocketConfig as a, type MiddlewareClass as b, type MiddlewareConstructor as c, type MiddlewareContext as d, type MiddlewareFn as e, type PresenceInfo as f, type PresenceMember as g, type SocketAuthenticationResult as h, type SocketEvents as i, type SocketHealthSnapshot as j, type SocketHttpMiddleware as k, type SocketOriginResolver as l, type SocketOriginValues as m, SocketResponseError as n, type SocketRetryQueueConfig as o, type SocketServiceStatus as p, type SocketTransportConfig as q, type SocketUpgradeContext as r, type BaseChannelConstructor as s, type ChannelMiddlewareRunnerFactory as t, type ChannelMatch as u, type PresenceData as v };

package/build/chunk-55EIQ2VV.js

@@ -0,0 +1,152 @@
+import {
+  buildChannelName,
+  callClientHandler,
+  resolveChannel
+} from "./chunk-O6UYCGTV.js";
+
+// src/client/framework.ts
+function createChannelCallArgs(pattern, parameters) {
+  return parameters === void 0 ? [pattern] : [pattern, parameters];
+}
+function resolveChannelEventArgs(args) {
+  return {
+    parameterInput: args.length === 3 ? args[0] : void 0,
+    event: args.at(-2),
+    handler: args.at(-1)
+  };
+}
+var socketEntries = /* @__PURE__ */ new WeakMap();
+var socketOwners = /* @__PURE__ */ new WeakMap();
+function reportSubscriptionError(error) {
+  queueMicrotask(() => {
+    console.error(error);
+  });
+}
+function attachEvents(entry) {
+  for (const [event, managed] of entry.events) {
+    entry.channel.$listen(event, managed.dispatch);
+  }
+}
+function getEntry(socket, name) {
+  let entries = socketEntries.get(socket);
+  if (!entries) {
+    entries = /* @__PURE__ */ new Map();
+    socketEntries.set(socket, entries);
+  }
+  const channel = socket[resolveChannel](name);
+  let entry = entries.get(name);
+  if (!entry || entry.channel !== channel) {
+    entry = {
+      channel,
+      socket,
+      leases: /* @__PURE__ */ new Set(),
+      events: /* @__PURE__ */ new Map(),
+      lifecycle: void 0
+    };
+    entries.set(name, entry);
+  }
+  return entry;
+}
+var ChannelLease = class {
+  entry;
+  #released = false;
+  #listeners = [];
+  constructor(entry) {
+    this.entry = entry;
+  }
+  listen(event, handler) {
+    if (this.#released) return;
+    let managed = this.entry.events.get(event);
+    if (!managed) {
+      const handlers = /* @__PURE__ */ new Set();
+      managed = {
+        handlers,
+        dispatch: (data) => {
+          for (const listener of handlers) callClientHandler(listener, data);
+        }
+      };
+      this.entry.events.set(event, managed);
+      this.entry.channel.$listen(event, managed.dispatch);
+    }
+    const registration = (data) => handler(data);
+    managed.handlers.add(registration);
+    this.#listeners.push({ event, handler: registration });
+  }
+  release() {
+    if (this.#released) return;
+    this.#released = true;
+    for (const { event, handler } of this.#listeners) {
+      const managed = this.entry.events.get(event);
+      managed?.handlers.delete(handler);
+      if (managed?.handlers.size === 0) {
+        this.entry.channel.$stopListening(event, managed.dispatch);
+        this.entry.events.delete(event);
+      }
+    }
+    this.#listeners = [];
+    this.entry.leases.delete(this);
+    queueMicrotask(() => {
+      if (this.entry.leases.size > 0) return;
+      const lifecycle = this.entry.lifecycle;
+      this.entry.lifecycle = void 0;
+      void lifecycle?.release().then(() => {
+        if (this.entry.leases.size > 0 || this.entry.lifecycle) return;
+        const entries = socketEntries.get(this.entry.socket);
+        if (entries?.get(this.entry.channel.name) === this.entry) {
+          entries.delete(this.entry.channel.name);
+        }
+      });
+    });
+  }
+};
+function acquireChannel(socket, ...args) {
+  const [pattern, parameters] = args;
+  const name = buildChannelName(pattern, parameters);
+  const entry = getEntry(socket, name);
+  const lease = new ChannelLease(entry);
+  entry.leases.add(lease);
+  if (!entry.lifecycle) {
+    const lifecycle = entry.channel.$acquire();
+    entry.lifecycle = lifecycle;
+    attachEvents(entry);
+    void lifecycle.ready.then(() => {
+      if (entry.lifecycle === lifecycle) attachEvents(entry);
+    }).catch((error) => {
+      if (entry.lifecycle === lifecycle && entry.leases.size > 0 && entry.socket.connected) {
+        reportSubscriptionError(error);
+      }
+    });
+  }
+  return { channel: entry.channel, lease };
+}
+function acquireSocketOwnership(socket) {
+  let owner = socketOwners.get(socket);
+  if (!owner) {
+    owner = { count: 0, generation: 0 };
+    socketOwners.set(socket, owner);
+    socket.connect().catch(reportSubscriptionError);
+  }
+  owner.count++;
+  owner.generation++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    owner.count--;
+    const generation = ++owner.generation;
+    queueMicrotask(() => {
+      if (owner.count === 0 && owner.generation === generation) {
+        socket.disconnect();
+        socketOwners.delete(socket);
+      }
+    });
+  };
+}
+
+export {
+  createChannelCallArgs,
+  resolveChannelEventArgs,
+  acquireChannel,
+  acquireSocketOwnership
+};
+//# sourceMappingURL=chunk-55EIQ2VV.js.map

package/build/chunk-55EIQ2VV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/framework.ts"],"sourcesContent":["import type { Channel } from './channel.js'\nimport { buildChannelName, resolveChannel, type Socket } from './socket.js'\nimport type {\n  ChannelCallArgs,\n  ChannelContract,\n  ChannelContractFor,\n  ChannelParameters,\n  ChannelPattern,\n  EventHandler,\n} from './types.js'\nimport { callClientHandler } from './callback.js'\n\ntype AnySocket = Socket<any>\ntype ServerEvents<Contract> =\n  Contract extends ChannelContract<unknown, infer Events> ? Events : unknown\n\ntype FrameworkChannelMember<Registry, Pattern extends string> =\n  ChannelContractFor<Registry, Pattern> extends infer Contract\n    ? [Contract] extends [never]\n      ? never\n      : Channel<Contract>\n    : never\n\nexport type FrameworkChannel<Registry, Pattern extends string> = FrameworkChannelMember<\n  Registry,\n  Pattern\n>\n\nexport type FrameworkChannelPattern<Registry> = ChannelPattern<Registry>\nexport type FrameworkChannelCallArgs<Registry> = ChannelCallArgs<Registry>\nexport type FrameworkChannelParameters<\n  Registry,\n  Pattern extends ChannelPattern<Registry>,\n> = ChannelParameters<Registry, Pattern>\n\nexport function createChannelCallArgs<Registry>(\n  pattern: ChannelPattern<Registry>,\n  parameters?: object\n): ChannelCallArgs<Registry> {\n  return (parameters === undefined ? [pattern] : [pattern, parameters]) as ChannelCallArgs<Registry>\n}\n\n/** Resolves the shared positional arguments accepted by framework channel-event helpers. @internal */\nexport function resolveChannelEventArgs<ParameterInput, Event extends string, Payload>(\n  args: readonly unknown[]\n): {\n  parameterInput: ParameterInput | undefined\n  event: Event\n  handler: EventHandler<Payload>\n} {\n  return {\n    parameterInput: (args.length === 3 ? args[0] : undefined) as ParameterInput | undefined,\n    event: args.at(-2) as Event,\n    handler: args.at(-1) as EventHandler<Payload>,\n  }\n}\n\nexport type FrameworkChannelEvent<Registry, Pattern extends string> =\n  FrameworkChannel<Registry, Pattern> extends Channel<infer Contract>\n    ? Extract<keyof ServerEvents<Contract>, string>\n    : never\n\nexport type FrameworkChannelEventPayload<\n  Registry,\n  Pattern extends string,\n  Event extends FrameworkChannelEvent<Registry, Pattern>,\n> =\n  FrameworkChannel<Registry, Pattern> extends Channel<infer Contract>\n    ? Event extends keyof ServerEvents<Contract>\n      ? ServerEvents<Contract>[Event]\n      : never\n    : never\n\ninterface ManagedEvent {\n  handlers: Set<EventHandler<any>>\n  dispatch: EventHandler<any>\n}\n\ninterface ManagedEntry {\n  channel: Channel<any>\n  socket: AnySocket\n  leases: Set<ChannelLease>\n  events: Map<string, ManagedEvent>\n  lifecycle: { ready: Promise<Channel<any>>; release: () => Promise<void> } | undefined\n}\n\nconst socketEntries = new WeakMap<AnySocket, Map<string, ManagedEntry>>()\nconst socketOwners = new WeakMap<AnySocket, { count: number; generation: number }>()\n\nfunction reportSubscriptionError(error: unknown): void {\n  queueMicrotask(() => {\n    console.error(error)\n  })\n}\n\nfunction attachEvents(entry: ManagedEntry): void {\n  for (const [event, managed] of entry.events) {\n    entry.channel.$listen(event, managed.dispatch)\n  }\n}\n\nfunction getEntry(socket: AnySocket, name: string): ManagedEntry {\n  let entries = socketEntries.get(socket)\n  if (!entries) {\n    entries = new Map()\n    socketEntries.set(socket, entries)\n  }\n\n  const channel = socket[resolveChannel](name)\n  let entry = entries.get(name)\n  if (!entry || entry.channel !== channel) {\n    entry = {\n      channel,\n      socket,\n      leases: new Set(),\n      events: new Map(),\n      lifecycle: undefined,\n    }\n    entries.set(name, entry)\n  }\n\n  return entry\n}\n\nexport class ChannelLease {\n  readonly entry: ManagedEntry\n  #released = false\n  #listeners: Array<{ event: string; handler: EventHandler<any> }> = []\n\n  constructor(entry: ManagedEntry) {\n    this.entry = entry\n  }\n\n  listen(event: string, handler: EventHandler<any>): void {\n    if (this.#released) return\n\n    let managed = this.entry.events.get(event)\n    if (!managed) {\n      const handlers = new Set<EventHandler<any>>()\n      managed = {\n        handlers,\n        dispatch: (data) => {\n          for (const listener of handlers) callClientHandler(listener, data)\n        },\n      }\n      this.entry.events.set(event, managed)\n      this.entry.channel.$listen(event, managed.dispatch)\n    }\n    const registration: EventHandler<any> = (data) => handler(data)\n    managed.handlers.add(registration)\n    this.#listeners.push({ event, handler: registration })\n  }\n\n  release(): void {\n    if (this.#released) return\n    this.#released = true\n\n    for (const { event, handler } of this.#listeners) {\n      const managed = this.entry.events.get(event)\n      managed?.handlers.delete(handler)\n      if (managed?.handlers.size === 0) {\n        this.entry.channel.$stopListening(event, managed.dispatch)\n        this.entry.events.delete(event)\n      }\n    }\n    this.#listeners = []\n    this.entry.leases.delete(this)\n\n    queueMicrotask(() => {\n      if (this.entry.leases.size > 0) return\n      const lifecycle = this.entry.lifecycle\n      this.entry.lifecycle = undefined\n      void lifecycle?.release().then(() => {\n        if (this.entry.leases.size > 0 || this.entry.lifecycle) return\n        const entries = socketEntries.get(this.entry.socket)\n        if (entries?.get(this.entry.channel.name) === this.entry) {\n          entries.delete(this.entry.channel.name)\n        }\n      })\n    })\n  }\n}\n\nexport function acquireChannel<Registry, const Args extends ChannelCallArgs<Registry>>(\n  socket: Socket<Registry>,\n  ...args: Args\n): { channel: FrameworkChannel<Registry, Args[0]>; lease: ChannelLease } {\n  const [pattern, parameters] = args as [string, object?]\n  const name = buildChannelName(pattern, parameters)\n  const entry = getEntry(socket, name)\n  const lease = new ChannelLease(entry)\n  entry.leases.add(lease)\n\n  if (!entry.lifecycle) {\n    const lifecycle = entry.channel.$acquire()\n    entry.lifecycle = lifecycle\n    attachEvents(entry)\n    void lifecycle.ready\n      .then(() => {\n        if (entry.lifecycle === lifecycle) attachEvents(entry)\n      })\n      .catch((error) => {\n        if (entry.lifecycle === lifecycle && entry.leases.size > 0 && entry.socket.connected) {\n          reportSubscriptionError(error)\n        }\n      })\n  }\n\n  return { channel: entry.channel as FrameworkChannel<Registry, Args[0]>, lease }\n}\n\n/** Connects an exclusively owned socket and coalesces development-mode remounts. */\nexport function acquireSocketOwnership(socket: AnySocket): () => void {\n  let owner = socketOwners.get(socket)\n  if (!owner) {\n    owner = { count: 0, generation: 0 }\n    socketOwners.set(socket, owner)\n    socket.connect().catch(reportSubscriptionError)\n  }\n  owner.count++\n  owner.generation++\n\n  let released = false\n  return () => {\n    if (released) return\n    released = true\n    owner.count--\n    const generation = ++owner.generation\n    queueMicrotask(() => {\n      if (owner.count === 0 && owner.generation === generation) {\n        socket.disconnect()\n        socketOwners.delete(socket)\n      }\n    })\n  }\n}\n"],"mappings":"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","names":[]}