experimental-a2 0.8.1 → 0.10.0

package/dist/actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor.js","names":["contract","createContract"],"sources":["../src/actor.ts"],"sourcesContent":["/**\n * experimental-a2/actor — durable actors over the log. Server-only\n * (handlers are server code); the browser condition resolves to a\n * throwing stub, and the browser surfaces are experimental-a2/actor/client\n * and experimental-a2/actor/react.\n *\n * An actor is defined over a protocol — its state shape and event\n * vocabulary, as types — and one complete `handlers` bag:\n *\n * ```ts\n * interface Counter {\n *   state: { count: number }\n *   events: { increment: object; add: { by: number } }\n * }\n * const counter = actor<Counter>({\n *   name: 'counter',\n *   state: { count: 0 },\n *   handlers: {\n *     increment: (ctx) => {\n *       ctx.state.count++\n *     },\n *     add: (ctx, input) => {\n *       ctx.state.count += input.by\n *     },\n *   },\n * })\n * ```\n *\n * Handlers are serial by default: one at a time per instance (a lane —\n * the state's write lock), `ctx.state` a mutable draft committed\n * atomically with completion. A handler holding slow I/O opts out of\n * the lane with `{ concurrent: true, handle }`: it runs in parallel,\n * reads state as a snapshot, and mutates by sending events whose\n * serial handlers decide against fresh state. `ctx.send.eventName(...)`\n * is typed by the protocol and buffered — committed atomically with\n * the handler's completion, so a reserve and its trigger can never\n * half-happen.\n *\n * A thrown `NonRetriableError` is an answer (settled, delivered to a\n * waiting caller); any other error retries like every A2 handler\n * failure; a crash re-runs against the same pre-state. Everything\n * compiles to contract + reducer + laned handlers + returned events —\n * no new store operations, no new wire.\n */\n\n// oxlint-disable no-await-in-loop -- a call awaits its answer: drain, read\n// the tail, repeat until the message settles. Sequential by nature.\n\nimport {\n  ACTOR_FAILED_EVENT,\n  ACTOR_LANE,\n  ACTOR_STATE_EVENT,\n  ActorRefusedError,\n  actorFailedSchema,\n  actorReducer,\n  actorStateSchema,\n  isJsonTree,\n  openPresenceDefs,\n} from './actor-shared.ts'\nimport type {\n  ActorClientEventDefs,\n  ActorConcurrentContext,\n  ActorContext,\n  ActorFailedPayload,\n  ActorPresenceOf,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n  ActorStatePayload,\n} from './actor-shared.ts'\nimport { parsePresenceSibling } from './push-envelope.ts'\nimport type { ParsedPushPresence } from './push-envelope.ts'\nimport { contract as createContract } from './contract.ts'\nimport type { PresencePatch, PresenceSnapshot } from './contract.ts'\nimport type { Contract, EventDefs } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport { A2Error, NonRetriableError } from './errors.ts'\nimport { createServer } from './server.ts'\nimport { setServerFetchHooks } from './server-fetch.ts'\nimport { sseResponse } from './sse.ts'\nimport type { A2Scheduler, A2Server, HandlerEntry, Session } from './server.ts'\nimport type { A2Store } from './store.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\nimport type { A2Telemetry } from './telemetry.ts'\n\nexport type {\n  ActorConcurrentContext,\n  ActorContext,\n  ActorPresenceMap,\n  ActorPresenceOf,\n  ActorPresenceValues,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n} from './actor-shared.ts'\nexport { ActorRefusedError } from './actor-shared.ts'\n\n/**\n * One event's handler: ordinary server code. Serial by default — read\n * `ctx.state`, perform I/O, mutate `ctx.state`, one atomic commit at\n * return. `{ concurrent: true, handle }` opts the handler out of the\n * lane for slow I/O: state becomes a snapshot read and mutations\n * happen by sending events. The input is typed by the protocol; the\n * wire hands handlers parsed JSON, so a wire-exposed event guards its\n * input in its first line (`schema.parse(input)` if you like schemas —\n * userland either way).\n */\nexport type ActorHandler<D extends ActorProtocol, K extends keyof D['events']> =\n  | ((ctx: ActorContext<D>, input: D['events'][K]) => void | Promise<void>)\n  | {\n      concurrent: true\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: D['events'][K],\n      ) => void | Promise<void>\n    }\n\n/**\n * Mark a handler concurrent — off the lane, in parallel with the lane\n * and with other concurrent handlers, `ctx.state()` a snapshot read.\n * Sugar for the structural `{ concurrent: true, handle }` form:\n *\n * ```ts\n * handlers: {\n *   transfer: concurrent(async (ctx, input) => {\n *     await bank.transfer(input, { idempotencyKey: input.ref })\n *     ctx.send.settle({ ref: input.ref })\n *   }),\n * }\n * ```\n */\nexport function concurrent<Ctx, I>(\n  handle: (ctx: Ctx, input: I) => void | Promise<void>,\n): { concurrent: true; handle: (ctx: Ctx, input: I) => void | Promise<void> } {\n  return { concurrent: true, handle }\n}\n\nexport type ActorOptions<D extends ActorProtocol> = {\n  /** Identity — prefixes storage keys; one contract per actor definition. */\n  name: string\n  /** The initial state — checked against the protocol, a plain JSON tree. */\n  state: D['state']\n  /**\n   * One handler per declared event — completeness and payload shapes\n   * are compile-checked against the protocol.\n   */\n  handlers: { [K in keyof D['events']]: ActorHandler<D, K> }\n  store?: A2Store\n  scheduler?: A2Scheduler\n  telemetry?: A2Telemetry\n} & ([ActorPresenceOf<D>] extends [never]\n  ? { presence?: never }\n  : {\n      /**\n       * The wire bit for the protocol's `presence` vocabulary — types\n       * erase, so the runtime needs one value to arm the presence\n       * lanes (frames on GET, envelopes on POST). Required exactly\n       * when the protocol declares `presence`; the vocabulary itself\n       * is typed there. Values are validated to the JSON floor and\n       * pass through `authorize` as `{ type: 'presence' }` operations;\n       * meaning stays with your renderers — treat values as user\n       * input.\n       */\n      presence: true\n    })\n\n/**\n * One HTTP operation `handle.fetch` is about to serve — the actor\n * mirror of core's `A2Operation`. `authorize` sees it before any\n * write or subscription; returning `false` answers 403.\n */\nexport type ActorOperation =\n  | {\n      readonly type: 'stream'\n      readonly id: string\n      readonly startAfter: number\n    }\n  | {\n      readonly type: 'call'\n      readonly id: string\n      readonly event: string\n      readonly input: unknown\n      readonly messageId?: string\n    }\n  | {\n      readonly type: 'presence'\n      readonly id: string\n      readonly participant: string\n      readonly values: Readonly<Record<string, unknown>>\n    }\n\nexport type ActorFetchOptions<D extends ActorProtocol> = {\n  /** Per-operation policy — authentication happened in your route. */\n  authorize?: (operation: ActorOperation) => boolean | Promise<boolean>\n  /**\n   * Request-time projection: what this mount's audience sees. Applied\n   * to every state frame on the stream AND to call answers (the two\n   * untrusted lanes must agree, or the call lane leaks what the\n   * stream hides). The definition stays audience-agnostic — different\n   * routes project the same actor differently, and per-viewer views\n   * are just closures over the route's auth. Output is held to the\n   * JSON-tree floor like everything else. Transport-agnostic: applied\n   * at frame emission, so any wire the door speaks emits projected\n   * frames. Absent, the full state ships (the trusted default).\n   */\n  view?: (state: D['state']) => unknown\n}\n\nexport type ActorSendOptions = {\n  /** Explicit message id — makes retries of this send idempotent. */\n  id?: string\n}\n\nexport type ActorCallOptions = ActorSendOptions & {\n  /** How long to await the answer before rejecting the wait (default 30s). */\n  timeoutMs?: number\n}\n\nexport type ActorCallResult<S> = {\n  /** The actor's state after this message was processed. */\n  state: S\n  /** Log index of the state commit that answered this message. */\n  index: number\n}\n\ntype CallMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n  : (\n      input: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n\ntype SendMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n  : (\n      input: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n\n/** One instance: typed calls and sends, reads, the managed door, the escape hatch. */\nexport type ActorHandle<D extends ActorProtocol> = {\n  readonly id: string\n  /**\n   * Send the event and await its answer: the state after the handler\n   * ran, or a rejection with `ActorRefusedError`. Serial events only —\n   * concurrent handlers produce no answer to await; `send` them.\n   */\n  readonly call: { readonly [K in keyof D['events']]: CallMethod<D, K> }\n  /** Cast: validate, append the event durably, return without waiting. */\n  readonly send: { readonly [K in keyof D['events']]: SendMethod<D, K> }\n  /** Snapshot read — never queues behind pending messages. */\n  readonly state: () => Promise<ActorCallResult<D['state']>>\n  /**\n   * The managed door — the actor mirror of `server.fetch`, bound to\n   * this instance. GET streams the state plane (`a2.actor.state`\n   * commits only, `?index` resume, heartbeat, deadline rotation);\n   * POST is the call lane `createActorClient` speaks (`{ event,\n   * input, messageId? }` → the answer, 409 for a refusal). Your route\n   * authenticates and picks the instance; `authorize` sees every\n   * operation. Custom endpoints are route code around this call.\n   */\n  readonly fetch: (\n    request: Request,\n    options?: ActorFetchOptions<D>,\n  ) => Promise<Response>\n  /** Escape hatch: the raw A2 session (history, stream, schedule). */\n  readonly session: Session<EventDefs>\n}\n\nexport type ActorDefinition<D extends ActorProtocol> = {\n  readonly name: string\n  /**\n   * Type-only carrier of the protocol, so clients deriving from\n   * `typeof def` can see the vocabularies (`experimental-a2/actor/react`\n   * types `presence` from it). Never a runtime value.\n   */\n  readonly protocol?: D\n  /** The assembled contract — declared events plus the reserved a2.actor.* pair. */\n  readonly contract: Contract<EventDefs>\n  /** The underlying A2 server — `server.fetch` mounts the full session wire. */\n  readonly server: A2Server<EventDefs>\n  /** The state fold — same identity as the client's follower fold. */\n  readonly reducer: Reducer<ActorClientEventDefs<D['state']>, D['state']>\n  actor(id: string): ActorHandle<D>\n}\n\n// Object-mechanics names, not surface names: events live in their own\n// bags, so nothing else is reserved.\nconst UNSAFE_EVENT_NAMES = new Set(['__proto__', 'constructor', 'prototype'])\n\nconst forbidden = (): Response =>\n  Response.json({ error: 'the operation is not authorized' }, { status: 403 })\n\nconst CALL_TIMEOUT_MS = 30_000\nconst CALL_POLL_MS = 25\n\n/** Declared events accept any JSON tree; `undefined` normalizes to `{}`. */\nconst jsonInputSchema: StandardSchemaV1<unknown> = {\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      if (value === undefined || value === null) return { value: {} }\n      if (!isJsonTree(value)) {\n        return {\n          issues: [{ message: 'event input must be a plain JSON tree' }],\n        }\n      }\n      return { value }\n    },\n  },\n}\n\nconst describeError = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms))\n\ntype NormalizedHandler<D extends ActorProtocol> =\n  | {\n      kind: 'serial'\n      handle: (ctx: ActorContext<D>, input: unknown) => void | Promise<void>\n    }\n  | {\n      kind: 'concurrent'\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: unknown,\n      ) => void | Promise<void>\n    }\n\n/**\n * Define and serve an actor over its protocol: a named, durable\n * instance-per-id with serialized state handlers, concurrent I/O\n * handlers, and typed self-sends.\n */\nexport function actor<D extends ActorProtocol>(\n  options: ActorOptions<D>,\n): ActorDefinition<D> {\n  const { name } = options\n\n  const handlersByEvent = new Map<string, NormalizedHandler<D>>()\n  const events: Record<string, StandardSchemaV1> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n    [ACTOR_FAILED_EVENT]: actorFailedSchema,\n  }\n  for (const [eventName, def] of Object.entries(\n    options.handlers as Record<string, ActorHandler<D, keyof D['events']>>,\n  )) {\n    if (UNSAFE_EVENT_NAMES.has(eventName)) {\n      throw new TypeError(\n        `actor '${name}': '${eventName}' collides with object plumbing and cannot name an event`,\n      )\n    }\n    if (eventName.startsWith('a2.')) {\n      throw new TypeError(\n        `actor '${name}': event names starting with 'a2.' are reserved`,\n      )\n    }\n    handlersByEvent.set(\n      eventName,\n      typeof def === 'function'\n        ? {\n            kind: 'serial',\n            handle: def as (\n              ctx: ActorContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          }\n        : {\n            kind: 'concurrent',\n            handle: def.handle as (\n              ctx: ActorConcurrentContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          },\n    )\n    events[eventName] = jsonInputSchema\n  }\n\n  const reducer = actorReducer({ name, state: options.state })\n  // The server's contract carries every event type; the reducer only\n  // folds state commits. Same fold, same identity — the widening is a\n  // typing formality.\n  const serverReducer = reducer as unknown as Reducer<EventDefs, D['state']>\n\n  // The typed durable-timer surface: immediate handoff to the\n  // configured scheduler through the handler session, so timer\n  // identity is scoped to the triggering message and re-runs address\n  // the same timer (core §6). Not buffered — see ActorScheduleSend.\n  const makeSchedule = (\n    schedule: (\n      name: string,\n      timing: { delay?: string; at?: Date },\n      event: { type: string; payload: unknown },\n    ) => Promise<void>,\n  ): ActorScheduleSend<D['events']> => {\n    const surface: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(surface, eventName, {\n        value: (input: unknown, scheduleOptions: ActorScheduleOptions) => {\n          const { name: taskName, ...timing } = scheduleOptions\n          return schedule(taskName ?? eventName, timing, {\n            type: eventName,\n            payload: input ?? {},\n          })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return surface as ActorScheduleSend<D['events']>\n  }\n\n  // The typed self-send surface: per-invocation buffers behind one\n  // shared method record shape. defineProperty so event names like\n  // 'constructor'-adjacent identifiers can never touch prototypes.\n  const makeSend = (\n    buffer: { type: string; payload: unknown }[],\n  ): ActorSend<D['events']> => {\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown) => {\n          buffer.push({ type: eventName, payload: input ?? {} })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return send as ActorSend<D['events']>\n  }\n\n  const handlers: Record<string, HandlerEntry<EventDefs>> = {}\n  for (const [eventName, def] of handlersByEvent) {\n    if (def.kind === 'concurrent') {\n      // No lane: concurrent handlers run in parallel — with the lane\n      // and with each other. They cannot write state (no draft to\n      // commit), so no serialization is needed for correctness; slow\n      // I/O lives here without blocking the actor.\n      handlers[eventName] = async (ctx) => {\n        const sends: { type: string; payload: unknown }[] = []\n        try {\n          await def.handle(\n            {\n              id: ctx.event.id,\n              attempt: ctx.attempt,\n              signal: ctx.signal,\n              send: makeSend(sends),\n              schedule: makeSchedule((taskName, timing, event) =>\n                ctx.session.schedule(\n                  taskName,\n                  timing as Parameters<typeof ctx.session.schedule>[1],\n                  event,\n                ),\n              ),\n              state: async () => {\n                const { state, index } = await ctx.session.state(\n                  serverReducer,\n                  { through: 'latest' },\n                )\n                return { state, index }\n              },\n            },\n            ctx.event.payload,\n          )\n        } catch (error) {\n          if (!(error instanceof NonRetriableError)) throw error\n          // A terminal failure is recorded for audit; nothing awaits a\n          // concurrent handler, so the marker is history, not an\n          // answer. Buffered sends are discarded — refusals are total,\n          // so compensate by completing (send then return), never by\n          // throwing.\n          const payload: ActorFailedPayload = {\n            message: ctx.event.id,\n            event: eventName,\n            error: describeError(error),\n          }\n          return { type: ACTOR_FAILED_EVENT, payload }\n        }\n        // Sends commit atomically with settlement; re-runs converge on\n        // the same deterministic message ids.\n        return sends\n      }\n      continue\n    }\n    handlers[eventName] = {\n      // One lane for every serial handler of one instance: the next\n      // message starts only after the previous one completed, and\n      // completion commits the state event atomically —\n      // read-modify-write on `ctx.state` is safe by exclusion, not by\n      // liveness.\n      lane: ACTOR_LANE,\n      handler: async (ctx) => {\n        // Explicitly 'latest', not the event-relative default: prior\n        // lane messages commit *after* this message was appended, so\n        // their state commits carry higher indexes than the trigger —\n        // an event-relative read would miss them and lose updates.\n        // 'latest' is deterministic here because the lane makes this\n        // attempt the only possible writer while it runs.\n        const { state } = await ctx.session.state(serverReducer, {\n          through: 'latest',\n        })\n        const draft = structuredClone(state)\n        const sends: { type: string; payload: unknown }[] = []\n        try {\n          await def.handle(\n            {\n              state: draft,\n              id: ctx.event.id,\n              attempt: ctx.attempt,\n              signal: ctx.signal,\n              send: makeSend(sends),\n              schedule: makeSchedule((taskName, timing, event) =>\n                ctx.session.schedule(\n                  taskName,\n                  timing as Parameters<typeof ctx.session.schedule>[1],\n                  event,\n                ),\n              ),\n            },\n            ctx.event.payload,\n          )\n        } catch (error) {\n          // A NonRetriableError is an answer: settle the message,\n          // record the refusal, deliver it to the waiting caller —\n          // no retry, no failure budget spent (buffered sends are\n          // discarded with the draft: refusals are total). Every\n          // other throw is an ordinary A2 handler failure: rethrown\n          // into core's retry machinery (backoff, ten-failure\n          // budget, dead letter) — including surrendered lease\n          // aborts, which core recognizes by identity.\n          if (!(error instanceof NonRetriableError)) throw error\n          const payload: ActorFailedPayload = {\n            message: ctx.event.id,\n            event: eventName,\n            error: describeError(error),\n          }\n          return { type: ACTOR_FAILED_EVENT, payload }\n        }\n        // One returned batch: buffered sends plus the state commit —\n        // committed atomically with completion, so a reserve and its\n        // trigger can never half-happen. The state event stays the\n        // outcome marker a waiting call resolves on. (Unconditional\n        // for now; a dirty check is a compatible later optimization.)\n        const payload: ActorStatePayload<D['state']> = {\n          state: draft,\n          event: eventName,\n          message: ctx.event.id,\n        }\n        return [...sends, { type: ACTOR_STATE_EVENT, payload }]\n      },\n    }\n  }\n\n  const presenceEnabled = (options as { presence?: unknown }).presence === true\n  // The '*' catch-all arms an open server-side vocabulary: the\n  // protocol types field names at compile time, the floor validates\n  // every value, and `authorize` sees every set. See openPresenceDefs.\n  const contract = presenceEnabled\n    ? createContract({ name, events, presence: openPresenceDefs })\n    : createContract({ name, events })\n  const server = createServer({\n    contract,\n    handlers,\n    ...(options.store ? { store: options.store } : {}),\n    ...(options.scheduler ? { scheduler: options.scheduler } : {}),\n    ...(options.telemetry ? { telemetry: options.telemetry } : {}),\n  })\n  // Single-writer discipline on the underlying session wire too: if an\n  // application mounts `def.server.fetch`, browsers may push declared\n  // events, never authored state or failure records.\n  setServerFetchHooks(server, {\n    validateIngress: ({ events: pushed }) => {\n      for (const event of pushed) {\n        if (event.type.startsWith('a2.actor.')) {\n          throw new TypeError(\n            `'${event.type}' is reserved — only a handler's completion can author it`,\n          )\n        }\n      }\n    },\n  })\n\n  const makeHandle = (id: string): ActorHandle<D> => {\n    const session = server.session(id)\n\n    const sendEvent = async (\n      eventName: string,\n      input: unknown,\n      sendOptions?: ActorSendOptions,\n    ): Promise<{ id: string; index: number }> => {\n      const [message] = await session.append({\n        type: eventName,\n        payload: input ?? {},\n        ...(sendOptions?.id ? { id: sendOptions.id } : {}),\n      })\n      if (!message) throw new Error('append returned no event')\n      return { id: message.id, index: message.index }\n    }\n\n    const callEvent = async (\n      eventName: string,\n      input: unknown,\n      callOptions?: ActorCallOptions,\n    ): Promise<ActorCallResult<D['state']>> => {\n      if (handlersByEvent.get(eventName)?.kind === 'concurrent') {\n        throw new TypeError(\n          `actor '${name}': '${eventName}' is concurrent — it produces no answer to await; send it instead`,\n        )\n      }\n      const message = await sendEvent(eventName, input, callOptions)\n      const deadline = Date.now() + (callOptions?.timeoutMs ?? CALL_TIMEOUT_MS)\n      let cursor = message.index + 1\n      for (;;) {\n        // Drain participates in processing (usually answering inline in\n        // this invocation); claims arbitrate if another process runs.\n        await server.drain(id)\n        const tail = await session.history({ gte: cursor })\n        for (const event of tail) {\n          if (event.type === ACTOR_STATE_EVENT) {\n            const payload = event.payload as ActorStatePayload<D['state']>\n            if (payload.message === message.id) {\n              return { state: payload.state, index: event.index }\n            }\n          }\n          if (event.type === ACTOR_FAILED_EVENT) {\n            const payload = event.payload as ActorFailedPayload\n            if (payload.message === message.id) {\n              throw new ActorRefusedError(eventName, message.id, payload.error)\n            }\n          }\n        }\n        const last = tail[tail.length - 1]\n        if (last) cursor = last.index + 1\n        if (Date.now() >= deadline) {\n          throw new Error(\n            `actor '${name}': timed out waiting for '${eventName}' (message ${message.id})`,\n          )\n        }\n        await sleep(CALL_POLL_MS)\n      }\n    }\n\n    const readState = async (): Promise<ActorCallResult<D['state']>> => {\n      const { state, index } = await session.state(serverReducer)\n      return { state, index }\n    }\n\n    const applyView = (\n      view: (state: D['state']) => unknown,\n      state: D['state'],\n    ): unknown => {\n      const viewed = view(state)\n      if (!isJsonTree(viewed)) {\n        throw new TypeError(\n          `actor '${name}': the view returned a value that is not a plain JSON tree`,\n        )\n      }\n      return viewed\n    }\n\n    const streamStates = async function* (\n      startAfter: number,\n      view?: (state: D['state']) => unknown,\n    ) {\n      // With presence armed, the session interleaves presence items\n      // (snapshot, then patches) between log events. They are\n      // ephemeral audience data, not actor state: they pass through\n      // untouched — views project state, never peers — and they never\n      // advance the resume frontier.\n      const source: AsyncIterable<\n        | Awaited<ReturnType<typeof session.history>>[number]\n        | PresencePatch\n        | PresenceSnapshot\n      > = presenceEnabled\n        ? (\n            session as unknown as {\n              stream(options: {\n                startAfter: number\n                presence: true\n              }): AsyncIterable<PresencePatch | PresenceSnapshot>\n            }\n          ).stream({ startAfter, presence: true })\n        : session.stream({ startAfter })\n      for await (const item of source) {\n        if (!('type' in item)) {\n          yield item\n          continue\n        }\n        const event = item\n        // The state plane only: subscribers see what the actor is,\n        // never other callers' inputs. Refusals answer only their\n        // caller (the POST 409); the full mailbox stays server-side.\n        if (event.type !== ACTOR_STATE_EVENT) continue\n        if (!view) {\n          yield event\n          continue\n        }\n        const payload = event.payload as ActorStatePayload<D['state']>\n        yield {\n          ...event,\n          payload: { ...payload, state: applyView(view, payload.state) },\n        }\n      }\n    }\n\n    // The managed door — the actor mirror of `server.fetch`: GET is\n    // the state-plane SSE (`a2.actor.state` commits only, `?index`\n    // resume), POST is the call lane (`{ event, input, messageId? }`\n    // → the answer, 409 for a refusal). Authentication happens in the\n    // surrounding route; per-operation policy in `authorize`.\n    const handleFetch = async (\n      request: Request,\n      fetchOptions?: ActorFetchOptions<D>,\n    ): Promise<Response> => {\n      const authorized = async (operation: ActorOperation): Promise<boolean> =>\n        (await fetchOptions?.authorize?.(Object.freeze(operation))) !== false\n\n      if (request.method === 'GET') {\n        const url = new URL(request.url)\n        const raw = Number(url.searchParams.get('index'))\n        const startAfter = Number.isSafeInteger(raw) && raw >= 0 ? raw : 0\n        if (!(await authorized({ type: 'stream', id, startAfter }))) {\n          return forbidden()\n        }\n        return sseResponse(streamStates(startAfter, fetchOptions?.view))\n      }\n      if (request.method !== 'POST') {\n        return new Response(null, {\n          status: 405,\n          headers: { allow: 'GET, POST' },\n        })\n      }\n      let body: unknown\n      try {\n        body = await request.json()\n      } catch {\n        return Response.json({ error: 'invalid JSON body' }, { status: 400 })\n      }\n      const record =\n        typeof body === 'object' && body !== null\n          ? (body as Record<string, unknown>)\n          : {}\n      if ('presence' in record) {\n        // A presence envelope — what the follower client's\n        // `setPresence` posts. Events never ride this lane: writes to\n        // the actor are calls.\n        if (!presenceEnabled) {\n          return Response.json(\n            { error: `actor '${name}' declares no presence` },\n            { status: 400 },\n          )\n        }\n        const pushedEvents = record['events']\n        if (\n          pushedEvents !== undefined &&\n          (!Array.isArray(pushedEvents) || pushedEvents.length > 0)\n        ) {\n          return Response.json(\n            { error: 'the actor wire takes calls, not event pushes' },\n            { status: 400 },\n          )\n        }\n        let patch: ParsedPushPresence\n        try {\n          const parsed = parsePresenceSibling(record['presence'])\n          if (!parsed) throw new TypeError('presence must be an object')\n          patch = parsed\n        } catch (error) {\n          return Response.json({ error: describeError(error) }, { status: 400 })\n        }\n        if (\n          !(await authorized({\n            type: 'presence',\n            id,\n            participant: patch.participant,\n            values: patch.values,\n          }))\n        ) {\n          return forbidden()\n        }\n        try {\n          await (\n            session as unknown as {\n              setPresence(patch: ParsedPushPresence): Promise<void>\n            }\n          ).setPresence(patch)\n        } catch (error) {\n          if (\n            error instanceof A2Error &&\n            (error.code === 'INVALID_PAYLOAD' ||\n              error.code === 'UNKNOWN_PRESENCE_FIELD')\n          ) {\n            return Response.json({ error: error.message }, { status: 400 })\n          }\n          throw error\n        }\n        return Response.json([])\n      }\n      const eventName = record['event']\n      if (\n        typeof eventName !== 'string' ||\n        handlersByEvent.get(eventName)?.kind !== 'serial'\n      ) {\n        return Response.json({ error: 'unknown event' }, { status: 400 })\n      }\n      const messageId = record['messageId']\n      if (messageId !== undefined && typeof messageId !== 'string') {\n        return Response.json({ error: 'invalid messageId' }, { status: 400 })\n      }\n      const input = record['input']\n      if (\n        !(await authorized({\n          type: 'call',\n          id,\n          event: eventName,\n          input,\n          ...(messageId === undefined ? {} : { messageId }),\n        }))\n      ) {\n        return forbidden()\n      }\n      try {\n        const result = await callEvent(\n          eventName,\n          input,\n          messageId === undefined ? undefined : { id: messageId },\n        )\n        return Response.json(\n          fetchOptions?.view\n            ? {\n                state: applyView(fetchOptions.view, result.state),\n                index: result.index,\n              }\n            : result,\n        )\n      } catch (error) {\n        if (error instanceof ActorRefusedError) {\n          return Response.json(\n            {\n              error: error.message,\n              event: error.event,\n              messageId: error.messageId,\n            },\n            { status: 409 },\n          )\n        }\n        if (\n          error instanceof A2Error &&\n          (error.code === 'INVALID_PAYLOAD' ||\n            error.code === 'UNKNOWN_EVENT_TYPE')\n        ) {\n          return Response.json({ error: error.message }, { status: 400 })\n        }\n        throw error\n      }\n    }\n\n    const call: Record<string, unknown> = {}\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(call, eventName, {\n        value: (input?: unknown, callOptions?: ActorCallOptions) =>\n          callEvent(eventName, input, callOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown, sendOptions?: ActorSendOptions) =>\n          sendEvent(eventName, input, sendOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n\n    const handle: ActorHandle<D> = {\n      id,\n      session,\n      call: call as ActorHandle<D>['call'],\n      send: send as ActorHandle<D>['send'],\n      state: readState,\n      fetch: handleFetch,\n    }\n    return handle\n  }\n\n  return {\n    name,\n    contract,\n    server,\n    reducer,\n    actor: makeHandle,\n  }\n}\n"],"mappings":"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"}

package/dist/ai-server.d.ts

@@ -1,5 +1,5 @@
-import { a as EventDefs, r as ContractEvent } from "./contract-jIfaR085.js";
-import { n as A2Server, p as ServerOptions } from "./server-DjPhHnbI.js";
+import { a as ContractEvent, s as EventDefs } from "./reducer-DJKWm3cp.js";
+import { n as A2Server, p as ServerOptions } from "./server-DgCrSuhB.js";
 import { AIEventDefs, AIState, AgentDefinition, AgentToolContext, AgentToolEventDefs } from "./ai.js";
 import { Instructions, LanguageModel, TextStreamPart, ToolSet, ToolSet as ToolSet$1, UIMessage, UIMessageChunk, streamText } from "ai";
 //#region src/ai-sdk-step.d.ts

package/dist/ai-server.js

@@ -1,6 +1,6 @@
-import { t as A2Error } from "./errors-BQuJpe82.js";
+import { t as A2Error } from "./errors-DCk6ch5n.js";
 import { f as consumeSchedulerSendFailure, p as installAmbientToolScopeStorage } from "./internal-DRXJ56EI.js";
-import { r as setServerFetchHooks, t as createServer } from "./server-B2XNevQA.js";
+import { r as setServerFetchHooks, t as createServer } from "./server-DlLyvaSH.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
 //#region src/ai-sdk-step.ts

package/dist/ai.d.ts

@@ -1,5 +1,5 @@
-import { a as EventDefs, h as StandardSchemaV1, n as Contract, p as Reducer, t as AppendInput } from "./contract-jIfaR085.js";
-import { s as HandlerContext } from "./server-DjPhHnbI.js";
+import { h as StandardSchemaV1, i as Contract, r as AppendInput, s as EventDefs, t as Reducer } from "./reducer-DJKWm3cp.js";
+import { s as HandlerContext } from "./server-DgCrSuhB.js";
 import { FinishReason, JSONValue, LanguageModelUsage, UIMessage, UIMessageChunk } from "ai";
 //#region src/ai.d.ts
 type AgentStatus = "idle" | "generating" | "waiting" | "failed" | "closed";

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { a as EventDefs, c as PresencePatch, d as WithPresence, o as PresenceDefs, p as Reducer, r as ContractEvent, s as PresenceMap, t as AppendInput } from "./contract-jIfaR085.js";
+import { a as ContractEvent, c as PresenceDefs, l as PresenceMap, p as WithPresence, r as AppendInput, s as EventDefs, t as Reducer, u as PresencePatch } from "./reducer-DJKWm3cp.js";
 //#region src/client.d.ts
 type ConnectionStatus = "idle" | "connecting" | "live" | "closed";
 /**
@@ -141,19 +141,25 @@ type A2Client<D extends EventDefs, S, P extends PresenceDefs = Record<never, nev
   session(sessionId: string, options?: SessionOptions<D, S>): SessionClient<D, S, P>;
 };
 /**
- * The wire the client rides. The string form is one route serving GET
+ * The wire the client rides. The first form is one route serving GET
  * (SSE stream) + POST (push). `http` splits the verbs across two
  * routes, for when platform duration limits differ per verb. `ws`
- * rides everything — every session of this client — over one
- * multiplexed WebSocket, served by `sessionsSocket`.
+ * rides everything over WebSocket, one socket per session by default.
+ * Multiplexing every session of the client is an explicit opt-in.
  */
-type ClientApi = string | {
+type SessionUrl = string | ((sessionId: string) => string);
+type ClientApi = SessionUrl | {
   type: "http";
-  push: string;
-  stream: string;
+  push: SessionUrl;
+  stream: SessionUrl;
+} | {
+  type: "ws";
+  url: SessionUrl;
+  multiplex?: false;
 } | {
   type: "ws";
   url: string;
+  multiplex: true;
 };
 /**
  * The socket surface the `ws` transport drives — satisfied structurally
@@ -198,5 +204,5 @@ type CreateClientOptions<D extends EventDefs, S, P extends PresenceDefs = Record
 };
 declare function createClient<D extends EventDefs, S, P extends PresenceDefs = Record<never, never>>(options: CreateClientOptions<D, S, P>): A2Client<D, S, P>;
 //#endregion
-export { A2Client, ClientApi, ClientWebSocket, ClientWebSocketConstructor, Connection, ConnectionStatus, CreateClientOptions, HistoryState, LoadHistoryOptions, PushResult, SessionClient, SessionClientPresence, SessionOptions, SessionSnapshot, createClient };
+export { A2Client, ClientApi, ClientWebSocket, ClientWebSocketConstructor, Connection, ConnectionStatus, CreateClientOptions, HistoryState, LoadHistoryOptions, PushResult, SessionClient, SessionClientPresence, SessionOptions, SessionSnapshot, SessionUrl, createClient };
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;KAoDY;;;;;;;KAQA;EACN;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;EAAgB;;EAChB;;;;;;;;;;KAUM,WAAW,UAAU,aAAa,QAAQ,cAAc;WACzD,WAAW,QAAQ,cAAc;;KAGhC;;;;;;EAMV;;EAEA;;;KAIU;;EAEV;;EAEA;;EAEA;;;KAIU,gBACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aACF;;EAGE,UAAU,YAAY;;;EAIxB,OAAO;;;;;EAKP,QAAQ,cAAc;;;EAGtB;;EAEA,SAAS;EACT,YAAY;;;;;;;KAQF,sBAAsB,UAAU;;;;;;;;;;EAU1C,YAAY,QAAQ,cAAc;;KAGxB,cACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aAAa,GAAG,sBAAsB;WAC/B;EACT,UAAU;EACV,eAAe,gBAAgB,GAAG,GAAG;;;;;;;;;;EAUrC,QAAQ,QAAQ,YAAY,OAAO,WAAW;;;;;;;;;;;EAW9C,YAAY,UAAU,qBAAqB,QAAQ,cAAc;;;;;;;;;EASjE;;;;;;EAMA;;KAGU,eAAe,UAAU,WAAW;EAC9C,eAAe;EACf;;EAEA,gBAAgB,cAAc;;;EAG9B;;KAGU,SACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,QACE,mBACA,UAAU,eAAe,GAAG,KAC3B,cAAc,GAAG,GAAG;;;;;;;;;KAUb;EAEN;EAAc;EAAc;;EAC5B;EAAY;;;;;;;KAON;WACD;EACT,KAAK;EACL,MAAM,eAAe;EACrB,iBAAiB,cAAc;EAC/B,iBACE,iBACA,WAAW;IAAS;;EAEtB,iBACE,eACA,WAAW;IAAS;IAAc;;EAEpC,iBAAiB,eAAe;;KAGtB,kCAAkC,gBAAgB;KAElD,oBACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,SAAS,QAAQ,GAAG,GAAG;;EAEvB,KAAK;;EAEL,eAAe,WAAW;;;EAG1B,YAAY;;;EAGZ;;;;;;;;EAQA;;iBAirBc,aACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,SAAS,oBAAoB,GAAG,GAAG,KAAK,SAAS,GAAG,GAAG"}
+{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;KAqDY;;;;;;;KAQA;EACN;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;EAAgB;;EAChB;;;;;;;;;;KAUM,WAAW,UAAU,aAAa,QAAQ,cAAc;WACzD,WAAW,QAAQ,cAAc;;KAGhC;;;;;;EAMV;;EAEA;;;KAIU;;EAEV;;EAEA;;EAEA;;;KAIU,gBACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aACF;;EAGE,UAAU,YAAY;;;EAIxB,OAAO;;;;;EAKP,QAAQ,cAAc;;;EAGtB;;EAEA,SAAS;EACT,YAAY;;;;;;;KAQF,sBAAsB,UAAU;;;;;;;;;;EAU1C,YAAY,QAAQ,cAAc;;KAGxB,cACV,UAAU,WACV,GACA,UAAU,eAAe,wBACvB,aAAa,GAAG,sBAAsB;WAC/B;EACT,UAAU;EACV,eAAe,gBAAgB,GAAG,GAAG;;;;;;;;;;EAUrC,QAAQ,QAAQ,YAAY,OAAO,WAAW;;;;;;;;;;;EAW9C,YAAY,UAAU,qBAAqB,QAAQ,cAAc;;;;;;;;;EASjE;;;;;;EAMA;;KAGU,eAAe,UAAU,WAAW;EAC9C,eAAe;EACf;;EAEA,gBAAgB,cAAc;;;EAG9B;;KAGU,SACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,QACE,mBACA,UAAU,eAAe,GAAG,KAC3B,cAAc,GAAG,GAAG;;;;;;;;;KAUb,wBAAwB;KAExB,YACR;EACE;EAAc,MAAM;EAAY,QAAQ;;EAExC;EAAY,KAAK;EAAY;;EAE7B;EAAY;EAAa;;;;;;;KAOnB;WACD;EACT,KAAK;EACL,MAAM,eAAe;EACrB,iBAAiB,cAAc;EAC/B,iBACE,iBACA,WAAW;IAAS;;EAEtB,iBACE,eACA,WAAW;IAAS;IAAc;;EAEpC,iBAAiB,eAAe;;KAGtB,kCAAkC,gBAAgB;KAElD,oBACV,UAAU,WACV,GACA,UAAU,eAAe;EAEzB,SAAS,QAAQ,GAAG,GAAG;;EAEvB,KAAK;;EAEL,eAAe,WAAW;;;EAG1B,YAAY;;;EAGZ;;;;;;;;EAQA;;iBAi6Bc,aACd,UAAU,WACV,GACA,UAAU,eAAe,sBACzB,SAAS,oBAAoB,GAAG,GAAG,KAAK,SAAS,GAAG,GAAG"}

package/dist/client.js

@@ -1,7 +1,7 @@
 import { n as validateSync } from "./validate-XKT4FSNn.js";
-import { t as A2Error } from "./errors-BQuJpe82.js";
-import { a as PRESENCE_TIMINGS, c as STREAM_TIMINGS, h as nullProtoRecord } from "./internal-DRXJ56EI.js";
-import { c as isWireEvent, d as parseSocketFrame, f as presencePatchFromWire, l as isWirePresencePatch, m as presenceSnapshotFromWire, o as eventFromWire, r as errorFromWire, u as isWirePresenceSnapshot } from "./wire-B6te_wns.js";
+import { t as A2Error } from "./errors-DCk6ch5n.js";
+import { a as PRESENCE_TIMINGS, c as STREAM_TIMINGS, h as nullProtoRecord, o as RESERVED_PARTICIPANT_IDS } from "./internal-DRXJ56EI.js";
+import { c as isWireEvent, d as parseSocketFrame, f as presencePatchFromWire, l as isWirePresencePatch, m as presenceSnapshotFromWire, o as eventFromWire, r as errorFromWire, u as isWirePresenceSnapshot } from "./wire--yji6mO3.js";
 //#region src/client.ts
 /**
 * experimental-a2/client — the framework-agnostic session client.
@@ -20,10 +20,15 @@ import { c as isWireEvent, d as parseSocketFrame, f as presencePatchFromWire, l
 const PUSH_ATTEMPTS = 3;
 const DEFAULT_GC_TIME_MS = 3e5;
 const DEFAULT_HISTORY_LIMIT = 50;
+const sessionUrl = (url, sessionId) => {
+	const resolved = typeof url === "function" ? url(sessionId) : url;
+	if (typeof resolved !== "string") throw new TypeError("a session URL function must return a string");
+	return resolved;
+};
 const httpTransport = (routes, fetchImpl, presence) => ({
 	async *connect({ sessionId, startAfter, signal }) {
-		const sep = routes.stream.includes("?") ? "&" : "?";
-		const res = await fetchImpl(`${routes.stream}${sep}sessionId=${encodeURIComponent(sessionId)}&index=${startAfter}`, {
+		const streamUrl = sessionUrl(routes.stream, sessionId);
+		const res = await fetchImpl(`${streamUrl}${streamUrl.includes("?") ? "&" : "?"}sessionId=${encodeURIComponent(sessionId)}&index=${startAfter}`, {
 			headers: { accept: "text/event-stream" },
 			signal
 		});
@@ -75,7 +80,7 @@ const httpTransport = (routes, fetchImpl, presence) => ({
 		}
 	},
 	async push(body) {
-		const res = await fetchImpl(routes.push, {
+		const res = await fetchImpl(sessionUrl(routes.push, body.sessionId), {
 			method: "POST",
 			headers: { "content-type": "application/json" },
 			body: JSON.stringify(body)
@@ -88,8 +93,8 @@ const httpTransport = (routes, fetchImpl, presence) => ({
 		throw errorFromWire(await res.json().catch(() => null)) ?? new A2Error("STORE_UNAVAILABLE", `push failed with ${res.status}`);
 	},
 	async history({ sessionId, gte, lte }) {
-		const sep = routes.stream.includes("?") ? "&" : "?";
-		const res = await fetchImpl(`${routes.stream}${sep}sessionId=${encodeURIComponent(sessionId)}&gte=${gte}&lte=${lte}`, { headers: { accept: "application/json" } });
+		const streamUrl = sessionUrl(routes.stream, sessionId);
+		const res = await fetchImpl(`${streamUrl}${streamUrl.includes("?") ? "&" : "?"}sessionId=${encodeURIComponent(sessionId)}&gte=${gte}&lte=${lte}`, { headers: { accept: "application/json" } });
 		if (!res.ok) throw errorFromWire(await res.json().catch(() => null)) ?? new A2Error("STORE_UNAVAILABLE", `history failed with ${res.status}`);
 		const rows = await res.json();
 		if (!Array.isArray(rows) || !rows.every(isWireEvent)) throw new A2Error("STORE_UNAVAILABLE", "history response was not a list of events");
@@ -98,7 +103,7 @@ const httpTransport = (routes, fetchImpl, presence) => ({
 	sendPresence(envelope) {
 		(async () => {
 			try {
-				await (await fetchImpl(routes.push, {
+				await (await fetchImpl(sessionUrl(routes.push, envelope.sessionId), {
 					method: "POST",
 					headers: { "content-type": "application/json" },
 					body: JSON.stringify(envelope)
@@ -109,6 +114,217 @@ const httpTransport = (routes, fetchImpl, presence) => ({
 });
 /** `WebSocket.OPEN` — fixed by the spec, identical in every runtime. */
 const WS_OPEN = 1;
+const webSocketUrl = (value) => {
+	let resolved;
+	if (/^(https?|wss?):\/\//i.test(value)) resolved = new URL(value);
+	else {
+		const base = globalThis.location?.href;
+		if (base === void 0) throw new TypeError(`cannot resolve the relative ws url '${value}' without a browser location — pass an absolute ws:// or wss:// url`);
+		resolved = new URL(value, base);
+	}
+	if (resolved.protocol === "http:") resolved.protocol = "ws:";
+	else if (resolved.protocol === "https:") resolved.protocol = "wss:";
+	return resolved;
+};
+const socketReadyWaiters = () => {
+	const sessions = /* @__PURE__ */ new Map();
+	const notify = (sessionId) => {
+		const waiters = sessions.get(sessionId);
+		if (!waiters) return;
+		sessions.delete(sessionId);
+		for (const waiter of waiters) waiter();
+	};
+	const wait = (sessionId, maxWaitMs) => new Promise((resolve) => {
+		let waiters = sessions.get(sessionId);
+		if (!waiters) {
+			waiters = /* @__PURE__ */ new Set();
+			sessions.set(sessionId, waiters);
+		}
+		let settled = false;
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			waiters.delete(done);
+			if (waiters.size === 0) sessions.delete(sessionId);
+			resolve();
+		};
+		const timer = setTimeout(done, maxWaitMs);
+		timer.unref?.();
+		waiters.add(done);
+	});
+	return {
+		notify,
+		wait
+	};
+};
+const rejectPendingAcks = (pending) => {
+	if (pending.size === 0) return;
+	const error = new A2Error("STORE_UNAVAILABLE", "socket closed with the ack outstanding");
+	for (const waiter of pending.values()) waiter.reject(error);
+	pending.clear();
+};
+const sessionWsTransport = (url, webSocketImpl, presence) => {
+	const connections = /* @__PURE__ */ new Map();
+	const ready = socketReadyWaiters();
+	let nextReq = 1;
+	const socketUrl = (sessionId, startAfter) => {
+		const resolved = webSocketUrl(sessionUrl(url, sessionId));
+		resolved.searchParams.set("sessionId", sessionId);
+		resolved.searchParams.set("index", String(startAfter));
+		return resolved.href;
+	};
+	return {
+		async *connect({ sessionId, startAfter, signal }) {
+			if (webSocketImpl === void 0) throw new TypeError("no WebSocket implementation available — pass one via createClient({ webSocket }) where the global is missing");
+			const socket = new webSocketImpl(socketUrl(sessionId, startAfter));
+			const connection = {
+				socket,
+				pending: /* @__PURE__ */ new Map()
+			};
+			connections.set(sessionId, connection);
+			const queue = [];
+			let ended = false;
+			let failure = null;
+			let wake = null;
+			const notify = () => {
+				wake?.();
+				wake = null;
+			};
+			const finish = (error) => {
+				if (ended) return;
+				ended = true;
+				failure = error;
+				if (connections.get(sessionId) === connection) connections.delete(sessionId);
+				rejectPendingAcks(connection.pending);
+				notify();
+			};
+			socket.addEventListener("open", () => {
+				if (connections.get(sessionId) !== connection || ended) return;
+				queue.push({ kind: "ping" });
+				notify();
+				ready.notify(sessionId);
+			});
+			socket.addEventListener("message", (event) => {
+				if (connections.get(sessionId) !== connection || ended) return;
+				if (typeof event.data !== "string") return;
+				const frame = parseSocketFrame(event.data);
+				if (frame === null) return;
+				switch (frame.kind) {
+					case "ack": {
+						const waiter = connection.pending.get(frame.req);
+						if (waiter === void 0) return;
+						connection.pending.delete(frame.req);
+						if (frame.sessionId !== void 0 || "events" in frame && frame.events.some((row) => row.sessionId !== sessionId)) {
+							waiter.reject(new A2Error("STORE_UNAVAILABLE", "ack does not belong to the socket session"));
+							return;
+						}
+						if ("events" in frame) waiter.resolve(frame.events);
+						else waiter.reject(frame.error);
+						return;
+					}
+					case "event":
+						if (frame.event.sessionId !== sessionId) return;
+						queue.push({
+							kind: "event",
+							event: frame.event
+						});
+						break;
+					case "presence":
+						if (presence && frame.sessionId === void 0) queue.push({
+							kind: "presence",
+							patch: frame.patch
+						});
+						break;
+					case "presence-snapshot":
+						if (presence && frame.sessionId === void 0) queue.push({
+							kind: "presence-snapshot",
+							snapshot: frame.snapshot
+						});
+						break;
+					case "ping":
+						queue.push(frame);
+						break;
+					case "subscribed":
+					case "unsubscribed": return;
+				}
+				notify();
+			});
+			socket.addEventListener("close", (event) => {
+				finish(event.code === 1e3 ? null : /* @__PURE__ */ new Error(`socket closed (${event.code}${event.reason ? `: ${event.reason}` : ""})`));
+			});
+			socket.addEventListener("error", () => {
+				finish(/* @__PURE__ */ new Error("socket error"));
+			});
+			const onAbort = () => {
+				finish(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("stream aborted"));
+				try {
+					socket.close(1e3);
+				} catch {}
+			};
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+			try {
+				for (;;) {
+					while (queue.length > 0) yield queue.shift();
+					if (ended) {
+						if (failure) throw failure;
+						return;
+					}
+					await new Promise((resolve) => {
+						wake = resolve;
+					});
+				}
+			} finally {
+				signal.removeEventListener("abort", onAbort);
+				finish(null);
+				try {
+					socket.close(1e3);
+				} catch {}
+			}
+		},
+		async push(body) {
+			const connection = connections.get(body.sessionId);
+			if (connection === void 0 || connection.socket.readyState !== WS_OPEN) throw new A2Error("STORE_UNAVAILABLE", "no open socket for the session");
+			const req = nextReq;
+			nextReq += 1;
+			return await new Promise((resolve, reject) => {
+				connection.pending.set(req, {
+					resolve,
+					reject
+				});
+				const frame = {
+					kind: "push",
+					req,
+					events: body.events
+				};
+				try {
+					connection.socket.send(JSON.stringify(frame));
+				} catch (cause) {
+					connection.pending.delete(req);
+					reject(new A2Error("STORE_UNAVAILABLE", "socket send failed", { cause }));
+				}
+			});
+		},
+		awaitReady(sessionId, maxWaitMs) {
+			if (connections.get(sessionId)?.socket.readyState === WS_OPEN) return Promise.resolve();
+			return ready.wait(sessionId, maxWaitMs);
+		},
+		sendPresence(envelope) {
+			const connection = connections.get(envelope.sessionId);
+			if (connection === void 0 || connection.socket.readyState !== WS_OPEN) return;
+			const frame = {
+				kind: "presence",
+				...envelope.presence
+			};
+			try {
+				connection.socket.send(JSON.stringify(frame));
+			} catch {
+				return;
+			}
+		}
+	};
+};
 const wakeChannel = (channel) => {
 	channel.wake?.();
 	channel.wake = null;
@@ -119,34 +335,16 @@ const subscribeFrame = (sessions) => {
 		sessions
 	});
 };
-const wsTransport = (url, webSocketImpl, presence) => {
+const multiplexedWsTransport = (url, webSocketImpl, presence) => {
 	const channels = /* @__PURE__ */ new Map();
 	const pending = /* @__PURE__ */ new Map();
 	/** Push retries parked in `awaitReady`, flushed per session on its
 	* subscribe confirmation. */
-	const readyWaiters = /* @__PURE__ */ new Map();
+	const ready = socketReadyWaiters();
 	let socket = null;
 	let socketOpen = false;
 	let watchdog;
 	let nextReq = 1;
-	const flushReadyWaiters = (sessionId) => {
-		const waiters = readyWaiters.get(sessionId);
-		if (!waiters) return;
-		readyWaiters.delete(sessionId);
-		for (const waiter of waiters) waiter();
-	};
-	const socketUrl = () => {
-		let resolved;
-		if (/^(https?|wss?):\/\//i.test(url)) resolved = new URL(url);
-		else {
-			const base = globalThis.location?.href;
-			if (base === void 0) throw new TypeError(`cannot resolve the relative ws url '${url}' without a browser location — pass an absolute ws:// or wss:// url`);
-			resolved = new URL(url, base);
-		}
-		if (resolved.protocol === "http:") resolved.protocol = "ws:";
-		else if (resolved.protocol === "https:") resolved.protocol = "wss:";
-		return resolved.href;
-	};
 	const trySend = (data) => {
 		if (socket === null || !socketOpen) return;
 		try {
@@ -169,11 +367,7 @@ const wsTransport = (url, webSocketImpl, presence) => {
 		socketOpen = false;
 		clearTimeout(watchdog);
 		watchdog = void 0;
-		if (pending.size > 0) {
-			const rejection = new A2Error("STORE_UNAVAILABLE", "socket closed with the ack outstanding");
-			for (const waiter of pending.values()) waiter.reject(rejection);
-			pending.clear();
-		}
+		rejectPendingAcks(pending);
 		return current;
 	};
 	const failSocket = (failure) => {
@@ -218,7 +412,7 @@ const wsTransport = (url, webSocketImpl, presence) => {
 				if (channel === void 0 || channel.ended || channel.live) return;
 				channel.live = true;
 				deliver(channel, { kind: "ping" });
-				flushReadyWaiters(frame.sessionId);
+				ready.notify(frame.sessionId);
 				return;
 			}
 			case "unsubscribed": {
@@ -267,7 +461,7 @@ const wsTransport = (url, webSocketImpl, presence) => {
 	const ensureSocket = () => {
 		if (socket !== null) return;
 		if (webSocketImpl === void 0) throw new TypeError("no WebSocket implementation available — pass one via createClient({ webSocket }) where the global is missing");
-		const created = new webSocketImpl(socketUrl());
+		const created = new webSocketImpl(webSocketUrl(url).href);
 		socket = created;
 		socketOpen = false;
 		armWatchdog(created);
@@ -378,25 +572,7 @@ const wsTransport = (url, webSocketImpl, presence) => {
 		awaitReady(sessionId, maxWaitMs) {
 			const channel = channels.get(sessionId);
 			if (channel !== void 0 && channel.live && !channel.ended && socketOpen) return Promise.resolve();
-			return new Promise((resolve) => {
-				let waiters = readyWaiters.get(sessionId);
-				if (!waiters) {
-					waiters = /* @__PURE__ */ new Set();
-					readyWaiters.set(sessionId, waiters);
-				}
-				let settled = false;
-				const done = () => {
-					if (settled) return;
-					settled = true;
-					clearTimeout(timer);
-					waiters.delete(done);
-					if (waiters.size === 0) readyWaiters.delete(sessionId);
-					resolve();
-				};
-				const timer = setTimeout(done, maxWaitMs);
-				timer.unref?.();
-				waiters.add(done);
-			});
+			return ready.wait(sessionId, maxWaitMs);
 		},
 		sendPresence(envelope) {
 			const channel = channels.get(envelope.sessionId);
@@ -411,7 +587,7 @@ const wsTransport = (url, webSocketImpl, presence) => {
 	};
 };
 const transportFor = (api, fetchImpl, webSocketImpl, presence) => {
-	if (typeof api === "string") return httpTransport({
+	if (typeof api === "string" || typeof api === "function") return httpTransport({
 		push: api,
 		stream: api
 	}, fetchImpl, presence);
@@ -419,7 +595,11 @@ const transportFor = (api, fetchImpl, webSocketImpl, presence) => {
 		push: api.push,
 		stream: api.stream
 	}, fetchImpl, presence);
-	return wsTransport(api.url, webSocketImpl, presence);
+	if (api.multiplex === true) {
+		if (typeof api.url !== "string") throw new TypeError("a multiplexed WebSocket URL must be a string");
+		return multiplexedWsTransport(api.url, webSocketImpl, presence);
+	}
+	return sessionWsTransport(api.url, webSocketImpl, presence);
 };
 function createClient(options) {
 	const { reducer, api } = options;
@@ -659,7 +839,7 @@ function createClient(options) {
 			const validated = nullProtoRecord();
 			for (const [field, value] of Object.entries(values)) {
 				if (value === void 0) continue;
-				const schema = Object.hasOwn(presenceDefs, field) ? presenceDefs[field] : void 0;
+				const schema = Object.hasOwn(presenceDefs, field) ? presenceDefs[field] : RESERVED_PARTICIPANT_IDS.has(field) ? void 0 : presenceDefs["*"];
 				if (!schema) throw new A2Error("UNKNOWN_PRESENCE_FIELD", `no presence field '${field}' in the reducer's vocabulary`);
 				if (value === null) {
 					validated[field] = null;