lecodes-sdk 2.0.4 → 2.0.5

package/src/server/auth/models.ts

@@ -1,83 +1,66 @@
 /**
- * `auth.model.user({...})` / `auth.model.session()` — the ONLY place auth touches the schema
- * (docs/backend-plan.md §3.4 / decision 10). Both return ordinary `model(...)`s: the developer registers
- * them in `defineDb({ User, Session, … })` under exactly those keys (other models relate to them with
- * `t.one("User")` / `t.one("Session")`), and `defineDb` adds `Session` itself when it isn't declared —
- * a device session exists from the first request, before any login, so every project db has one.
+ * The two models sign-in adds to a database — `defineDb({...}).withAuth({ model: "User" })`:
  *
- * Provider identity columns (`googleId`, `appleId`) follow `app.json` `auth.providers`, which the
- * compiler hands the server bundle through ./appConfig.ts (a module it replaces at compile time).
+ *   Session   one device: the hash of its token, and the user it is signed in as (none = a guest)
+ *   Identity  one way a user signs in: `email:<address>` or `login:<name>` (with the password's hash
+ *             when one is set) — several per user.
+ *
+ * They are the PLATFORM's: a project never declares them and never writes to them — it may refer to a
+ * session (`t.one("Session")`: a guest's cart) and read both through `db.auth.sessions` /
+ * `db.auth.identities`, which leave the secrets out. The user model is the project's own, an ordinary
+ * `model({...})`: the platform creates a row of it the first time someone signs in and knows nothing
+ * of it but the id.
  */
 
-import { t, type Field } from "../db/fields"
-import type { Fields, Model } from "../db/types"
-import { app, type AppConfig, type AuthProvider } from "./appConfig"
+import { t } from "../db/fields"
 
-export type { AppConfig, AuthProvider }
+export type { AppConfig } from "./appConfig"
 
-const seam = globalThis as unknown as { __lecodesApp?: AppConfig }
-/** The project's `app.json` subset: the compiled-in module, else the test/tooling seam, else empty. */
-export const appConfig = (): AppConfig => (Object.keys(app).length ? app : seam.__lecodesApp ?? {})
-export const enabledProviders = (): AuthProvider[] => appConfig().auth?.providers ?? []
+/** What an `Identity` row is of: an email, or a login (a name with no address behind it). */
+export type IdentityProvider = "email" | "login"
 
-/** The model name the auth runtime binds to. */
-export const AUTH_USER_MODEL = "User"
 export const AUTH_SESSION_MODEL = "Session"
+export const AUTH_IDENTITY_MODEL = "Identity"
 
-/** Marker on the two auth models (`model()` objects are otherwise plain). */
-export type AuthModelKind = "user" | "session"
-export type AuthModel<F extends Fields> = Model<F> & { readonly __auth: AuthModelKind }
-
-// ───────────────────────────── field sets ─────────────────────────────
-
-/** Built-in `User` fields (what `auth.user` is typed with). */
-export const userFields = () => ({
-  email:     t.string().optional().unique(),
-  name:      t.string().optional(),
-  avatar:    t.string().optional(),
-  /** Plain string column, `"user"` by default — `auth.requireUser({ role: "admin" })` is field equality. */
-  role:      t.string().default("user"),
-  createdAt: t.date().default("now"),
+/** A session as a project reads it (`db.auth.sessions`, a `t.one("Session")` relation). */
+export const sessionPublicFields = () => ({
+  createdAt:  t.date().default("now"),
+  lastSeenAt: t.date().default("now"),
+  revoked:    t.bool().default(false),
 })
-export type UserFields = ReturnType<typeof userFields>
+export type SessionPublicFields = ReturnType<typeof sessionPublicFields>
 
-/** `<provider>Id` identity columns for the OAuth providers enabled in app.json. */
-const providerFields = (): Record<string, Field<any, any>> => {
-  const out: Record<string, Field<any, any>> = {}
-  for (const p of enabledProviders()) if (p !== "email") out[`${p}Id`] = t.string().optional().unique()
-  return out
-}
-
-/** Built-in `Session` fields. `user` is added by `defineDb` when a `User` model exists (schema-time, so a
- *  db without an auth user model has sessions without a user column). */
-export const sessionFields = () => ({
+/** The whole `Session`; `user` points at the model `withAuth` named. */
+export const sessionFields = (userModel: string) => ({
   /** sha256 of the bearer token the device holds — the token itself is never stored. */
   tokenHash:    t.string().unique(),
-  createdAt:    t.date().default("now"),
-  lastSeenAt:   t.date().default("now"),
-  revoked:      t.bool().default(false),
+  ...sessionPublicFields(),
   // email-code sign-in state lives on the requesting session (no code table)
   pendingEmail: t.string().optional(),
   codeHash:     t.string().optional(),
   codeExpires:  t.date().optional(),
   codeAttempts: t.int().default(0),
+  user:         t.one(userModel).optional().onDelete("cascade"),
 })
-export type SessionFields = ReturnType<typeof sessionFields> & { user: ReturnType<typeof sessionUserField> }
-export const sessionUserField = () => t.one(AUTH_USER_MODEL).optional().onDelete("cascade")
-
-// ───────────────────────────── factories ─────────────────────────────
 
-// Built inline (not via defineDb's `model()`) to keep this module import-free of defineDb, which imports us.
-const authModel = <F extends Fields>(kind: AuthModelKind, fields: F): AuthModel<F> =>
-  ({ fields, __model: true, __auth: kind }) as AuthModel<F>
-
-/** `auth.model.user({...extra})` — the built-in user (+ provider ids from app.json) plus the developer's fields. */
-export const authUserModel = <E extends Fields = {}>(extra?: E): AuthModel<UserFields & E> =>
-  authModel("user", { ...userFields(), ...providerFields(), ...(extra ?? {}) } as UserFields & E)
-
-/** `auth.model.session({...extra})` — declare it only to relate to sessions (`t.one("Session")`) or to add fields. */
-export const authSessionModel = <E extends Fields = {}>(extra?: E): AuthModel<SessionFields & E> =>
-  authModel("session", { ...sessionFields(), ...(extra ?? {}) } as unknown as SessionFields & E)
+/** A sign-in method as a project reads it (`db.auth.identities`) — no hash. */
+export const identityPublicFields = () => ({
+  /** `"email" | "login"` */
+  provider:   t.string().index(),
+  /** What the person types to sign in: the address, or the login. */
+  subject:    t.string().index(),
+  /** When the subject was proven (a code). Unset = a password sign-up whose address wasn't confirmed. */
+  verifiedAt: t.date().optional(),
+  createdAt:  t.date().default("now"),
+})
+export type IdentityPublicFields = ReturnType<typeof identityPublicFields>
 
-export const isAuthModel = (m: unknown, kind?: AuthModelKind): m is AuthModel<any> =>
-  typeof m === "object" && m !== null && "__auth" in m && (kind === undefined || (m as AuthModel<any>).__auth === kind)
+/** The whole `Identity`. */
+export const identityFields = (userModel: string) => ({
+  user:       t.one(userModel).onDelete("cascade"),
+  ...identityPublicFields(),
+  /** `<provider>:<subject>` — marcidb has no composite @unique, this is the one-row-per-identity guarantee. */
+  key:        t.string().unique(),
+  /** scrypt hash of the password (`email` / `login` identities). */
+  hash:       t.string().optional(),
+})

package/src/server/auth/types.ts

@@ -1,50 +1,35 @@
 /**
- * Shared shapes of the auth layer (docs/backend-plan.md §3.4). Two sides meet through them:
- *  - the BUNDLE side (`auth` global, ./global.ts) — what `*.server.ts` code calls;
- *  - the HOST side (./host.ts) — sessions, email codes and OAuth binding, run by the runner with the
- *    project's db handle and the platform's secrets. Installed on `globalThis.__lecodesAuth`.
+ * Shared shapes of the auth layer. Two sides meet through them:
+ *  - the BUNDLE side (`db.auth`, ./api.ts) — what `*.server.ts` code calls;
+ *  - the HOST side (./host.ts) — sessions, passwords and email codes, run by the runner with the
+ *    project's db handle. Installed on `globalThis.__lecodesAuth`.
  */
 
 import type { RequestContext } from "../context"
-import type { AuthProvider } from "./models"
 
-/** The built-in user row — what `auth.user` is typed with (custom fields exist at runtime; select them via `db.user`). */
-export type AuthUser = {
-  id: number
-  email: string | null
-  name: string | null
-  avatar: string | null
-  role: string
-  createdAt: number
-}
-
-/** Per-request auth state, resolved by the host before the endpoint runs (`RequestContext.auth`). */
+/** Per-request auth state, resolved by the host before the endpoint runs (`RequestContext.auth`): the
+ *  device's session and the id of the user it is signed in as. Nothing of the user's row — a project
+ *  reads that itself (`db.auth.user()`). */
 export type AuthState = {
   sessionId: number
   userId: number | null
-  user: AuthUser | null
   /** A token to hand back to the client in this response (a new guest session, or a rotation). */
   issuedToken?: string
 }
 
-/** What an OAuth provider hands the runner after a successful web sign-in. */
-export type OAuthProfile = { sub: string, email?: string | null, emailVerified?: boolean, name?: string | null, avatar?: string | null }
-/** A credential a NATIVE provider SDK produced in the app (client plugin `OAuth.signIn`): an access token
- *  (Yandex, VK ID) or an OpenID identity token (Google, Apple). Verified server-side, never trusted as-is. */
-export type OAuthCredential = { accessToken?: string, idToken?: string, name?: string | null, email?: string | null }
-
-/** Host operations the bundle's `auth` global forwards to (all request-scoped through `ctx`). */
+/** Host operations `db.auth` forwards to (all request-scoped through `ctx`). A sign-in resolves once the
+ *  session is bound; who it is bound to is read through `db.auth.user()`. */
 export type AuthOps = {
-  email: {
-    sendCode(ctx: RequestContext, email: string): Promise<void>
-    verify(ctx: RequestContext, email: string, code: string): Promise<AuthUser>
-  }
-  oauth: {
-    url(ctx: RequestContext, provider: Exclude<AuthProvider, "email">): Promise<string>
-    signIn(ctx: RequestContext, provider: Exclude<AuthProvider, "email">, credential: OAuthCredential): Promise<AuthUser>
-  }
-  signIn(ctx: RequestContext, userId: number): Promise<AuthUser>
+  /** `data` = the fields of the new user's row (the project's own model). */
+  signUpWithPassword(ctx: RequestContext, login: string, password: string, data?: Record<string, unknown>): Promise<void>
+  signInWithPassword(ctx: RequestContext, login: string, password: string): Promise<void>
+  setPassword(ctx: RequestContext, password: string): Promise<void>
+  sendCode(ctx: RequestContext, email: string): Promise<void>
+  signInWithCode(ctx: RequestContext, email: string, code: string): Promise<void>
+  signIn(ctx: RequestContext, userId: number): Promise<void>
   signOut(ctx: RequestContext): Promise<void>
-  /** `db.session` filtered to the current user's sessions (or just this device's, when signed out). */
+  /** The sessions of the current user (or just this device's, when signed out), as a query. */
   sessions(ctx: RequestContext): any
+  /** The current user's sign-in methods, as a query — the hash is not in it. */
+  identities(ctx: RequestContext): any
 }

package/src/server/channel.ts

@@ -1,56 +1,124 @@
 /**
- * Server side of channels (docs/backend-plan.md §3.3): typed pub/sub, server → client only.
+ * Channels: the server's messages to the app. A server function is a call from the app to the
+ * server; a channel is the other direction, typed by the same export.
  *
- *   type ChatEvents = { message: { from: string; text: string }; typing: { from: string } }
- *   export const chat = channel<ChatEvents>({ onJoin: room => { auth.requireUser() } })
- *   chat.publish(room, "message", { from, text })
+ *   export const postsChannel = channel<Post>()                       // to everyone listening
+ *   export const noticesChannel = channel<Notice>()                   // to each their own
+ *     .groupBy(async () => (await db.auth.requireUser().select({ id: true })).id)
+ *
+ *   postsChannel.publish(post)                  // server
+ *   noticesChannel.publish(userId, notice)
+ *
+ *   postsChannel.subscribe(post => …)           // app
+ *   noticesChannel.subscribe(notice => …)
+ *
+ * `groupBy` runs on the server when an app subscribes, with what the app passed to `subscribe`
+ * before the handler, and answers the group that subscriber is in; `publish(group, message)` reaches
+ * that group. `authorize` only decides who may listen. Both refuse by throwing (`ApiError`), and
+ * both run in the request scope of the subscriber, so `db.auth` works in them.
  *
  * A channel's identity is its export (`<path>#<name>`), assigned by the runtime when the bundle is
  * loaded (`loadServerModules`); `publish` before that is an error. Delivery goes through the
- * `globalThis.__lecodesPublish` seam the runner installs (same reason as ./context.ts: the bundle
- * carries its own SDK copy).
+ * `globalThis.__lecodesPublish` seam the host installs (same reason as ./context.ts: the bundle
+ * carries its own SDK copy). In the app the export is another object altogether — the proxy
+ * `__channel` of src/runtime/rpc.ts — which is why `subscribe` here only throws.
  */
 
-export type ChannelEvents = Record<string, unknown>
+import type { ChannelGroup } from "../runtime/wire"
+
+export type { ChannelGroup }
 
-export type ChannelOptions = {
-  /** Called when a client subscribes to `topic`; throw (e.g. `ApiError(403)`) to refuse. */
-  onJoin?: (topic: string) => void | Promise<void>
+/** What `subscribe` answers: the subscription lives until `close()`. */
+export type ChannelSubscription = { close(): void }
+
+export type SubscribeOptions = {
+  /** The connection dropped and came back: what was published in between is lost — read the state again. */
+  reconnect?: () => void
+  /** The server refused the subscription (a hook threw): an `RpcError`, its `status` the hook's.
+   *  Without it the refusal is logged. The subscription is not over: the server is asked again
+   *  when the session changes, so this may be called more than once. */
+  error?: (e: Error & { readonly status: number }) => void
+}
+
+/** A channel every subscriber hears alike. */
+export interface Channel<M> {
+  /** Who may listen: runs on the server at every subscription, throw to refuse. */
+  authorize(check: () => void | Promise<void>): Channel<M>
+  /** Split the subscribers: `group` runs on the server at every subscription — with what the app
+   *  passed to `subscribe` — and answers the group of that subscriber. Throw to refuse. */
+  groupBy<K extends ChannelGroup, A extends unknown[] = []>(group: (...args: A) => K | Promise<K>): GroupedChannel<M, K, A>
+  /** Server: send `message` to every subscriber (at most once — nothing is kept for a socket that is away). */
+  publish(message: M): void
+  /** App: listen until `close()`. */
+  subscribe(handler: (message: M) => void, options?: SubscribeOptions): ChannelSubscription
 }
 
-export interface Channel<E extends ChannelEvents> {
-  /** @internal set by the runtime: `<path>#<export>` */
+/** A channel whose subscribers are in groups (`groupBy`). */
+export interface GroupedChannel<M, K extends ChannelGroup, A extends unknown[]> {
+  /** Server: send `message` to the subscribers of `group`. */
+  publish(group: K, message: M): void
+  /** App: listen until `close()`; the arguments before the handler go to the channel's `groupBy`. */
+  subscribe(...args: [...args: A, handler: (message: M) => void, options?: SubscribeOptions]): ChannelSubscription
+}
+
+type Hook = (...args: any[]) => unknown
+
+/** @internal what the host reads of a channel (src/server/runtime.ts) */
+export type ChannelRecord = {
+  /** set by the runtime: `<path>#<export>` */
   __id: string | null
-  /** @internal */
   readonly __channel: true
-  readonly options: ChannelOptions
-  /** Deliver `event` with `payload` to every subscriber of `topic` (at-most-once). */
-  publish<K extends keyof E & string>(topic: string, event: K, payload: E[K]): void
+  __authorize: Hook | null
+  __groupBy: Hook | null
 }
 
-type Publisher = (channelId: string, topic: string, event: string, payload: unknown) => void
+type Publisher = (channelId: string, group: ChannelGroup | null, message: unknown) => void
 const seam = globalThis as unknown as { __lecodesPublish?: Publisher }
 
-/** Host hook (runner / test harness): where `publish` delivers to. */
+/** Host hook (runner / local backend / test harness): where `publish` delivers to. */
 export const setChannelPublisher = (publisher: Publisher | null) => {
   if (publisher) seam.__lecodesPublish = publisher
   else delete seam.__lecodesPublish
 }
 
-export const channel = <E extends ChannelEvents>(options: ChannelOptions = {}): Channel<E> => {
-  const ch: Channel<E> = {
+export const isChannelGroup = (v: unknown): v is ChannelGroup =>
+  typeof v === "string" || (typeof v === "number" && Number.isFinite(v))
+
+export const channel = <M = unknown>(): Channel<M> => {
+  const deliver = (group: ChannelGroup | null, message: unknown) => {
+    if (!ch.__id) throw new Error("channel.publish: the channel is not registered — export it from a *.server.ts file")
+    const publish = seam.__lecodesPublish
+    if (!publish) throw new Error("channel.publish: no host publisher installed")
+    publish(ch.__id, group, message)
+  }
+  const ch: ChannelRecord & Record<string, unknown> = {
     __id: null,
     __channel: true,
-    options,
-    publish(topic, event, payload) {
-      if (!ch.__id) throw new Error("channel.publish: the channel is not registered — export it from a *.server.ts file")
-      const publish = seam.__lecodesPublish
-      if (!publish) throw new Error("channel.publish: no host publisher installed")
-      publish(ch.__id, topic, event, payload)
+    __authorize: null,
+    __groupBy: null,
+    authorize(check: Hook) {
+      if (ch.__authorize) throw new Error("channel: authorize() is given once")
+      if (ch.__groupBy) throw new Error("channel: authorize() goes before groupBy() — or check inside groupBy")
+      ch.__authorize = check
+      return ch
+    },
+    groupBy(group: Hook) {
+      if (ch.__groupBy) throw new Error("channel: groupBy() is given once")
+      ch.__groupBy = group
+      return ch
+    },
+    publish(...args: unknown[]) {
+      if (!ch.__groupBy) return deliver(null, args[0])
+      if (args.length < 2) throw new Error("channel.publish: this channel has groups — publish(group, message)")
+      if (!isChannelGroup(args[0])) throw new Error(`channel.publish: a group is a string or a number, got ${args[0] === null ? "null" : typeof args[0]}`)
+      deliver(args[0], args[1])
+    },
+    subscribe() {
+      throw new Error("channel.subscribe: the app subscribes, the server publishes")
     },
   }
-  return ch
+  return ch as unknown as Channel<M>
 }
 
-export const isChannel = (v: unknown): v is Channel<any> =>
-  typeof v === "object" && v !== null && (v as Channel<any>).__channel === true
+export const isChannel = (v: unknown): v is ChannelRecord =>
+  typeof v === "object" && v !== null && (v as ChannelRecord).__channel === true

package/src/server/channelHub.ts

@@ -0,0 +1,153 @@
+/**
+ * The server end of the channel socket (../runtime/wire.ts), written once for every host that
+ * serves one: the runner (Bun's sockets, its native topics as the fan-out) and the local backend of
+ * `lecodes dev` (whatever ./serve gives it). A host hands over three things — how to send a frame
+ * to a socket, how to run a channel's hooks, and optionally its own fan-out — and feeds the hub the
+ * frames it receives.
+ *
+ *   const hub = createChannelHub({ send: (ws, frame) => ws.send(frame), subscribe: (scope, ch, args, ctx) => … })
+ *   const conn = hub.connect(ws, { scope, ip })      // on open
+ *   conn.message(text)                               // on every text frame
+ *   conn.close()                                     // on close
+ *   hub.publish(scope, ch, group, message)           // a channel's publish
+ *
+ * `scope` separates the projects one host serves (the runner: a slot's key); a host with one
+ * project passes "".
+ *
+ * Who is subscribed was decided for the session the socket had THEN. So a `hello` that changes the
+ * session drops every subscription of the socket — the client sends them again and the hooks run
+ * for the new one. A socket's frames are served ONE AT A TIME, in the order they came: a `hello`
+ * never overtakes the subscription sent before it, and two subscriptions of a guest do not mint two
+ * sessions.
+ */
+
+import type { RequestContext } from "./context"
+import type { InvokeResult } from "./runtime"
+import type { ChannelGroup, ServerFrame } from "../runtime/wire"
+
+type Ctx = Omit<RequestContext, "id">
+
+/** Where a group's frames go. The default keeps the sockets of a key in a set; a host whose
+ *  sockets have topics of their own (Bun) hands those over, and one publish is one native call. */
+export type HubFanout<S> = {
+  subscribe(socket: S, key: string): void
+  /** Also called for every key of a socket that closed. */
+  unsubscribe(socket: S, key: string): void
+  publish(key: string, frame: string): void
+}
+
+export type ChannelHubOptions<S> = {
+  send: (socket: S, frame: string) => void
+  /** Run the hooks of channel `ch` (createSubscribeGuard, wherever the bundle lives): `result` = the group. */
+  subscribe: (scope: string, ch: string, args: unknown[], ctx: Ctx) => Promise<InvokeResult>
+  fanout?: HubFanout<S>
+}
+
+export type HubConnection = {
+  message(raw: string): Promise<void>
+  close(): void
+}
+
+export type ChannelHub<S> = {
+  connect(socket: S, info: { scope?: string, ip?: string, session?: string | null }): HubConnection
+  publish(scope: string, ch: string, group: ChannelGroup | null, message: unknown): void
+}
+
+const keyOf = (scope: string, ch: string, group: ChannelGroup | null) => `${scope}|${ch}|${JSON.stringify(group)}`
+
+const setFanout = <S>(send: (socket: S, frame: string) => void): HubFanout<S> => {
+  const sockets = new Map<string, Set<S>>()
+  return {
+    subscribe(socket, key) {
+      let set = sockets.get(key)
+      if (!set) sockets.set(key, set = new Set())
+      set.add(socket)
+    },
+    unsubscribe(socket, key) {
+      const set = sockets.get(key)
+      if (set?.delete(socket) && set.size === 0) sockets.delete(key)
+    },
+    publish(key, frame) {
+      for (const socket of sockets.get(key) ?? []) send(socket, frame)
+    },
+  }
+}
+
+export const createChannelHub = <S>(opts: ChannelHubOptions<S>): ChannelHub<S> => {
+  const fanout = opts.fanout ?? setFanout(opts.send)
+  const frame = (f: ServerFrame) => JSON.stringify(f)
+
+  return {
+    connect(socket, info) {
+      const scope = info.scope ?? ""
+      let session = info.session ?? null
+      let closed = false
+      let queue: Promise<void> = Promise.resolve()
+      /** client sub id → key */
+      const subs = new Map<number, string>()
+      /** key → how many of this socket's subs are on it (the fan-out hears of the first and the last) */
+      const counts = new Map<string, number>()
+
+      const drop = (id: number) => {
+        const key = subs.get(id)
+        if (key === undefined) return
+        subs.delete(id)
+        const n = (counts.get(key) ?? 1) - 1
+        if (n > 0) { counts.set(key, n); return }
+        counts.delete(key)
+        fanout.unsubscribe(socket, key)
+      }
+      const dropAll = () => { for (const id of [...subs.keys()]) drop(id) }
+
+      const serve = async (msg: any) => {
+        switch (msg?.t) {
+          case "hello": {
+            const next = typeof msg.session === "string" && msg.session ? msg.session : null
+            if (next === session) return
+            session = next
+            dropAll()
+            return
+          }
+          case "sub": {
+            const id = Number(msg.id), ch = String(msg.ch ?? "")
+            if (!Number.isFinite(id) || !ch) return
+            const args = Array.isArray(msg.args) ? msg.args : []
+            const ctx: Ctx = { headers: session ? { authorization: `Bearer ${session}` } : {}, ip: info.ip, sessionToken: session ?? undefined }
+            const r = await opts.subscribe(scope, ch, args, ctx)
+            if (closed) return
+            // a token minted by the hooks (the first contact of a guest) → the client stores it
+            if (r.session) { session = r.session; opts.send(socket, frame({ t: "session", session: r.session })) }
+            if (!r.ok) { opts.send(socket, frame({ t: "err", id, status: r.status, message: r.message })); return }
+            const group = (r.result ?? null) as ChannelGroup | null
+            const key = keyOf(scope, ch, group)
+            drop(id)
+            opts.send(socket, frame({ t: "ok", id, group }))
+            subs.set(id, key)
+            counts.set(key, (counts.get(key) ?? 0) + 1)
+            if (counts.get(key) === 1) fanout.subscribe(socket, key)
+            return
+          }
+          case "unsub":
+            drop(Number(msg.id))
+            return
+        }
+      }
+
+      return {
+        message(raw) {
+          let msg: unknown
+          try { msg = JSON.parse(raw) } catch { return queue }
+          queue = queue.then(() => closed ? undefined : serve(msg)).catch(() => {})
+          return queue
+        },
+        close() {
+          closed = true
+          dropAll()
+        },
+      }
+    },
+    publish(scope, ch, group, message) {
+      fanout.publish(keyOf(scope, ch, group), frame({ t: "ev", ch, group, data: message === undefined ? null : message }))
+    },
+  }
+}

package/src/server/context.ts

@@ -7,13 +7,13 @@
  */
 
 export type RequestContext = {
-  /** Endpoint id `<path>#<export>` (or the channel id for `onJoin`). */
+  /** Endpoint id `<path>#<export>` (or the channel id for a subscription's hooks). */
   id: string
   headers: Record<string, string>
   ip?: string
   /** Bearer session token as sent by the client transport (raw; auth resolves it). */
   sessionToken?: string
-  /** Set by the auth runtime after resolving the token — read via `auth.*`, not here. */
+  /** Set by the auth runtime after resolving the token — read via `db.auth`, not here. */
   auth?: unknown
 }