hci-atrium 0.1.0

package/dist/rooms/room.d.ts

@@ -0,0 +1,542 @@
+/**
+ * The live room handle — pure transport over the room WebSocket. Returned by ``client.rooms.open`` /
+ * ``client.rooms.join(code)`` / the loginless {@link joinRoom}. Feature-equivalent to the Python
+ * SDK's ``Room`` (rooms.py) + ``AsyncRoom`` (aio.py), but JS needs no sync/async split — there is one
+ * API: ``room.on(...)`` registers, ``await room.request(...)`` correlates.
+ *
+ * Transport: everything rides one WebSocket (``/v1/rooms/{id}/ws``) — text signals *and* the
+ * ephemeral binary audio stream. That differs from the Python SDK (SSE receive + a REST ``/signal``
+ * POST); it's the extract-from-use path (the Player/tools already speak WS) and the only transport
+ * that carries binary. The REST ``/signal`` wire body is still the canonical cross-SDK shape
+ * ({@link ../shaping/rooms.buildRoomSignal}); the fields match field-for-field.
+ *
+ * Correlation (mirror of ``_RoomDispatcher``): dispatch starts with {@link connect}. Each inbound
+ * signal routes to the handler registered for its ``type``; a handler's return value is sent back as
+ * the response when the signal was a {@link request} (carried an ``ackId``) — so a responder writes
+ * no correlation plumbing, it just returns. Pending {@link request}s resolve by ``replyTo``.
+ *
+ * Durable & reactive surfaces (wave 2): {@link Room.record} bridges the room into a session over an
+ * SSE-observe {@link ./recorder.Recorder} (every WS send is ephemeral, so durable capture rides the
+ * observe stream); {@link Room.audioVectors} embeds the live snippet stream and {@link Room.audioScores}
+ * fuses it against named anchors for a {@link ../decider.Decider}. Still deferred to later waves: the
+ * ``offer_embeds`` / ``offer_chat`` broker protocol, and ``offerAudioCapture`` (which will bind to the
+ * active recorder via {@link Room.activeRecorders} / {@link Room.onRecordersChanged}).
+ */
+import { type AnchorLike, type OperandLike } from "../by.js";
+import type { FileSource } from "../files.js";
+import type { ChatReply, CompareResult, Session, Space, Transcript } from "../models.js";
+import type { ShapedRequest } from "../shaping/index.js";
+import type { AudioChunk, TranscribeStreamOptions } from "../transcribe.js";
+import { type AudioSignal } from "./codec.js";
+import { OfferedCapture } from "./offer-capture.js";
+import { OfferedTranscription } from "./offer-transcription.js";
+import { type Participant, type ParticipantPredicate } from "./participant.js";
+import { Recorder } from "./recorder.js";
+import { type FetchImpl } from "./sse.js";
+import { Transcriber } from "./transcriber.js";
+import { type RoomEndReason, type RosterEntry, type WebSocketCtor } from "./transport.js";
+/** One inbound room signal, camelCased — what a {@link Room.on} handler receives. */
+export interface RoomEvent {
+    type: string;
+    payload: Record<string, unknown>;
+    source: string | null;
+    /** The sender's connection id (server-stamped), or ``null`` for a server-emitted signal. */
+    from: string | null;
+    to: string | string[] | null;
+    /** Set when this signal is a request awaiting a reply — return a value from the handler to answer. */
+    ackId: string | null;
+    /** Set when this signal is a reply — correlates to a {@link Room.request}'s ``ackId``. */
+    replyTo: string | null;
+    ephemeral: boolean;
+}
+/** A signal handler. A returned value (or resolved promise) answers a {@link Room.request}. */
+export type Handler = (event: RoomEvent) => unknown | Promise<unknown>;
+/** One raw ~10s audio window from {@link Room.audioClips} — the decoded snippet plus its source. */
+export interface AudioClip {
+    /** The encoded audio bytes for this window (Opus-in-WebM from a browser producer). */
+    data: ArrayBuffer;
+    /** The producer's mime type for {@link data} (e.g. ``"audio/webm;codecs=opus"``). */
+    mime: string;
+    /** Monotonic per-producer counter from 0 — a consumer notices drops/reordering. */
+    sequence: number;
+    /** Non-overlapping window length in seconds (e.g. 10). */
+    windowSeconds: number;
+    /** The producer's connection id (a Capture tool's v2 attribution), or ``null`` for a Player (v1). */
+    source: string | null;
+    /** The producer's announced name, resolved from the roster snapshot **at subscribe time** — so a
+     * source that joins *after* this subscribes has ``null`` here until you re-subscribe. */
+    sourceName: string | null;
+}
+/** One embedded ~10s audio window from {@link Room.audioVectors} — a live vector of "what the room
+ * sounds like right now", embedded in ``space``. Ephemeral (never stored); compare it against your
+ * own anchors (concepts, text probes, example assets). Mirror of Python's ``AudioVector``. */
+export interface AudioVector {
+    vector: number[];
+    space: string;
+    sequence: number;
+    windowSeconds: number;
+    /** Unix seconds (a float) when the vector was computed. */
+    timestamp: number;
+}
+/** One {@link Room.audioScores} frame — an {@link AudioVector} fused against named anchors via
+ * ``library.compare``. ``scores`` is each anchor's calibrated compare score; ``mix`` normalizes them
+ * to sum 1 (uniform when every score is 0, so gate on ``max(scores)`` for silence rather than reading
+ * a uniform mix as "all tied"). No smoothing here — ease the stream with a {@link ../decider.Decider}.
+ * Mirror of Python's ``ScoredAudio``. */
+export interface ScoredAudio {
+    scores: Record<string, number>;
+    mix: Record<string, number>;
+    vector: number[];
+    space: string;
+    sequence: number;
+    windowSeconds: number;
+    timestamp: number;
+}
+/** The slice of the authenticated client a room's embedding surfaces call — injected by
+ * ``client.rooms`` for an owned room, and absent for a loginless {@link joinRoom} participant (which
+ * has no credentials to embed with). {@link Room.audioVectors} / {@link Room.audioScores} require it. */
+export interface RoomAudioClient {
+    embed(opts: {
+        model: string;
+        text?: string;
+        audio?: FileSource;
+        format?: string;
+    }): Promise<number[]>;
+    library: {
+        spaces(): Promise<Space[]>;
+        compare(a: OperandLike, b: OperandLike, opts?: {
+            space?: string;
+        }): Promise<CompareResult>;
+    };
+    request(req: ShapedRequest): Promise<unknown>;
+    /** Chat completion — what {@link Room.offerChat} generates a reply with (the broker pins the model). */
+    chat(messages: string | Array<{
+        role: string;
+        content: string;
+    }>, opts?: Record<string, unknown>): Promise<ChatReply>;
+    /** The shared live-transcription engine — what {@link Room.transcribe} runs the snippet stream
+     * through (streaming when the backend offers it, per-clip batch otherwise). */
+    transcribeStream(clips: AsyncIterable<AudioChunk>, opts: TranscribeStreamOptions): AsyncIterable<Transcript>;
+}
+/** How a {@link Room} carries text signals: ``"auto"`` prefers the WebSocket and falls back to
+ * SSE-receive + POST-send if the WS can't come up (a proxy stripping upgrades); ``"ws"`` / ``"sse"``
+ * pin one transport. Binary audio is WS-only regardless. Default ``"auto"``. */
+export type RoomTransportMode = "auto" | "ws" | "sse";
+/** REST metadata + connection deps a {@link Room} is built from. */
+export interface RoomDeps {
+    id: string;
+    connectCode: string;
+    name?: string | null;
+    projectId?: string | null;
+    /** The instance base URL (http/https). */
+    baseUrl: string;
+    /** Authenticated REST caller for management (rotate/delete); absent for participants. */
+    rest?: (req: ShapedRequest) => Promise<unknown>;
+    /** The authenticated client's embedding surfaces — set for an owned room, absent for a loginless
+     * participant; what {@link Room.audioVectors} / {@link Room.audioScores} run on. */
+    client?: RoomAudioClient;
+    /** Stable presence identity (e.g. ``"player:bob"``). */
+    identity?: string;
+    /** Presence announce metadata peers see on join. */
+    announce?: Record<string, unknown>;
+    /** Default {@link Room.request} timeout (ms). */
+    requestTimeout?: number;
+    /** Reconnect on unexpected drop (default true). */
+    reconnect?: boolean;
+    /** Signal transport preference (default ``"auto"`` — WS, falling back to SSE). */
+    transport?: RoomTransportMode;
+    /** Injected ``WebSocket`` constructor — the test seam. */
+    WebSocketCtor?: WebSocketCtor;
+    /** Injected ``fetch`` for the SSE transport / roster reads — the test seam. */
+    fetchImpl?: FetchImpl;
+    /** Aborting this closes the room. */
+    signal?: AbortSignal;
+}
+/** A random opaque id (a UUID with dashes stripped, else a time-seeded fallback) — request ack ids
+ * and dedicated-consumer socket identities. Shared with the standing offers ({@link ./standing-source}). */
+export declare function randomId(): string;
+export declare class Room {
+    readonly id: string;
+    connectCode: string;
+    name: string | null;
+    readonly projectId: string | null;
+    private readonly deps;
+    private socket;
+    private usingSse;
+    private connectPromise;
+    private readonly handlers;
+    private readonly anyHandlers;
+    private readonly pending;
+    private ended;
+    private readonly endListeners;
+    private readonly audioSubscribers;
+    private audioSocket;
+    private readonly layerWatchers;
+    private readonly recorders;
+    private readonly recorderListeners;
+    private readonly transcribers;
+    private readonly offeredServices;
+    private readonly brokerRoles;
+    constructor(deps: RoomDeps);
+    /** The server-assigned connection id, or ``null`` before {@link connect} settles. */
+    get connectionId(): string | null;
+    /** The live participant roster (excludes self), from the ``ready`` snapshot + presence deltas —
+     * the raw {@link RosterEntry} view. For the parsed, query-friendly {@link Participant} (merged
+     * ``roles`` / ``name`` / ``connectedAt``) use {@link participants} / {@link has}. */
+    get presence(): RosterEntry[];
+    /** Open the live socket and start dispatch; resolves once the server's ``ready`` frame arrives.
+     * Idempotent — safe to call repeatedly, and every wire method calls it for you. */
+    connect(): Promise<void>;
+    private startSocket;
+    private makeSse;
+    private handleEnd;
+    /** Register a handler for one signal type. The handler's return value auto-replies to a
+     * {@link request} (a signal carrying an ``ackId``) — so a responder just returns. */
+    on(type: string, handler: Handler): this;
+    /** Register a catch-all observer invoked for **every** inbound signal (replies included) — the
+     * parity for a raw `receive()` loop (logging, inspection). Observers never auto-reply. Returns an
+     * unsubscribe function. */
+    onAny(handler: (event: RoomEvent) => void): () => void;
+    /** Register a callback for a **terminal** room end — the connection stopped for good with a typed
+     * {@link RoomEndReason} (``"code-rotated"`` / ``"bad-code"`` / ``"room-gone"``), on either the WS or
+     * SSE transport and whether the end is rejected at connect time or happens mid-session. Fires
+     * **exactly once** per handle; a deliberate {@link close} is not an end and never fires it. Returns
+     * an unsubscribe function. The typed reason is what a driver maps to its own UI state instead of
+     * string-matching a request's reject message. Register before {@link connect} to catch a connect-time
+     * reject. Python owes the port (``on_end``). */
+    onEnd(cb: (reason: RoomEndReason) => void): () => void;
+    /** Send a live message — fire-and-forget, never stored. ``to`` (a connection id/identity, or a
+     * list) targets peers; omit it to broadcast to everyone else. (``ephemeral`` is accepted for
+     * parity, but the WS inbound path forces ``ephemeral: false`` server-side.) */
+    send(type: string, payload?: Record<string, unknown>, opts?: {
+        to?: string | string[];
+        ephemeral?: boolean;
+    }): Promise<void>;
+    /** Send a request and await one reply (a peer's handler return). ``to`` targets one peer; omit it
+     * to broadcast — first matching reply wins. Rejects if no reply arrives within the timeout. */
+    request(type: string, payload?: Record<string, unknown>, opts?: {
+        to?: string;
+        timeout?: number;
+    }): Promise<Record<string, unknown>>;
+    private handleSignal;
+    private handleAudioBinary;
+    private dispatchAudio;
+    private onReady;
+    /**
+     * Subscribe to the room's audio-signal stream — the continuous binary loudness/spectrum frames
+     * plus the ``audio.track`` / ``audio.beat`` / ``audio.announce`` text signals a hosted Player (or
+     * any producer) broadcasts. The callback receives a discriminated {@link AudioSignal}; switch on
+     * ``.kind``. The first subscriber opens a dedicated socket that announces ``role: audio-consumer``
+     * (a producer's broadcast gate) and sends an ``audio.discover`` on every (re)connect; the last
+     * unsubscribe closes it, releasing demand. Returns an unsubscribe function.
+     */
+    audioSignals(callback: (signal: AudioSignal) => void): () => void;
+    private openAudioSocket;
+    /** Refuse fast if this handle latched onto the SSE transport (the WS upgrade wasn't reachable) —
+     * binary audio is WS-only, so a doomed WS reconnect would otherwise spin forever. Consulted by every
+     * audio consumer AND, via {@link offerDeps}, every standing offer, so signals and audio stay coherent
+     * about the environment. Throws {@link AtriumError}. When the transport isn't yet decided (the main
+     * socket hasn't connected), it proceeds — the offers, which engage over an already-live signal
+     * channel, always see the settled decision. */
+    private requireWsAudio;
+    /**
+     * Subscribe to the room's raw ``audio.snippet`` stream — the ~10s Opus windows a Player (v1) or a
+     * Capture tool (v2) shares — as an async iterator of {@link AudioClip}s. The rawest audio consumer:
+     * where a later ``audioVectors`` embeds and ``audioTranscripts`` transcribes, this hands you the
+     * bytes. Subscribing *is* the demand signal (it announces the ``audio-snippet-consumer`` role, so a
+     * producer's own default-off "Share audio clips" toggle actually captures). Break out of the
+     * ``for await`` loop (or ``return``) to end the subscription and close the socket.
+     *
+     * ``sourceName`` is resolved from the roster snapshot **at subscribe time**, so a producer that
+     * joins *after* this subscribes has ``null`` there until you re-subscribe (mirror of Python's
+     * ``audio_clips``). Binary rides the WebSocket only — a room latched to the SSE fallback throws.
+     */
+    audioClips(): AsyncGenerator<AudioClip>;
+    /**
+     * Start capturing this room's live signals into a durable ``session`` — the single durable binding
+     * between a room (pure transport) and a session (an append-only log). A **side effect**: it starts
+     * immediately in the background and returns a live {@link Recorder} handle. Stop it with
+     * ``rec.stop()``, or let {@link close} (an ``await using`` room) stop it. It skips ``ephemeral``
+     * signals and presence traffic — only durable-worthy signals are recorded, each stamped with
+     * ``via`` provenance (``{ room_id, room_name, from, to }``). Mirror of Python's ``room.record``.
+     *
+     * A dropped stream reconnects with backoff (the gap is lost — rooms have no replay); only a
+     * terminal end stops it cleanly with a {@link Recorder.stoppedReason} (a code rotation, or the
+     * room being gone / its code rejected — the latter also sets {@link Recorder.error}). Needs an
+     * owned room (durable sessions require an account) — throws on a loginless {@link joinRoom} handle.
+     */
+    record(into: Session): Recorder;
+    /** The recorders currently running on this handle (membership **and** liveness — a stopped one no
+     * longer counts) — the source of truth a wave-4 ``offerAudioCapture`` reads for audio-capture
+     * availability, and binds its capture to the first active recorder's session. */
+    activeRecorders(): Recorder[];
+    /** Register a listener fired whenever the active-recorder set changes (a {@link record} started, or
+     * a recorder stopped/terminated) — the seam a wave-4 ``offerAudioCapture`` binds to, so it can
+     * re-derive availability and disengage when the recorder it wrote under is gone. Returns an
+     * unsubscribe function. Mirror of Python's ``_notify_recorders_changed`` registration. */
+    onRecordersChanged(listener: () => void | Promise<void>): () => void;
+    private notifyRecordersChanged;
+    /**
+     * Transcribe this room's live audio into ``transcript.*`` signals — the in-room broker. Consumes the
+     * room's ``audio.snippet`` stream (announcing the snippet-consumer role, so a Player starts
+     * capturing), pushes it through the same engine as {@link ../atrium.Atrium.transcribeLive} on
+     * **your** credentials/compute, and publishes back:
+     *
+     * * ``transcript.partial`` — ``{ text }``, **ephemeral** (a live caption the recorder skips).
+     *   Wholesale-replaced — render the latest, don't append.
+     * * ``transcript.final`` — ``{ text, start, end, seq }``, durable (the {@link record} bridge persists
+     *   it — no new recording API). ``seq`` is a per-handle counter from 0; the signal's ``source`` is
+     *   ``"transcriber"``.
+     *
+     * Any consumer — including a loginless code-joined tool — just does ``room.on("transcript.final")``.
+     * Like {@link record}, it's a **side effect**: it starts immediately in the background and is stopped
+     * when the room closes, or via ``await handle.stop()`` / ``await using``. Needs an owned room
+     * (transcription runs on an account credential) — throws on a loginless {@link joinRoom} handle.
+     */
+    transcribe(opts?: {
+        model?: string;
+        language?: string;
+    }): Transcriber;
+    private snippetBytesFor;
+    /** Merge the registered broker/offer roles into the presence announce (mirror of Python's
+     * ``_events_params``) — so registering a broker before ``connect()`` rides the first connection. */
+    private mergedAnnounce;
+    private announceRole;
+    private requirePreConnect;
+    /** The single capability-injection guard — the authed client slice (embed / chat / compare /
+     * transcribe) an owned room carries and a loginless ``join(code)`` handle lacks. Always throws
+     * {@link AtriumError} (never a bare ``Error``), so every SDK refusal is catchable under the one
+     * hierarchy. ``feature`` names the surface for the message. */
+    private requireClient;
+    private offerDeps;
+    private offerService;
+    /**
+     * Offer live transcription as a peer-toggleable standing service — a code-joined tool turns it on
+     * with a ``transcription.start`` request and off with ``transcription.stop`` (both idempotent).
+     * Announces the discoverable ``transcription-offer`` role. **Scoped, multi-source**: ``start`` /
+     * ``stop`` are scoped to the requesting connection unless the payload carries ``{ all: true }``;
+     * only armed sources are transcribed (up to ``maxSources``, default 8). While on it runs the same
+     * engine as {@link transcribe} on **your** credentials, publishing source-attributed ``transcript.*``
+     * signals. Register **before** ``connect()``; needs an owned room (throws on a loginless handle).
+     * Returns the handle (for ``handle.start({ all: true })`` from the host). Mirror of Python's
+     * ``offer_transcription``.
+     */
+    offerTranscription(opts?: {
+        model?: string;
+        language?: string;
+        maxSources?: number;
+    }): OfferedTranscription;
+    /**
+     * Offer audio capture as a peer-toggleable standing service — **session-less**: it writes into the
+     * **active recorder's** session ({@link record} is the single durable binding), so a ``capture.start``
+     * with no active recorder replies an error. A code-joined tool toggles it via ``capture.start`` /
+     * ``capture.stop`` (idempotent). Announces the discoverable ``capture-offer`` role. **Scoped,
+     * multi-source** (up to ``maxSources``, default 8): only armed sources are recorded; a same-name
+     * reconnect within grace resumes one file, two simultaneous same-name producers get their own files.
+     * Register **before** ``connect()``; needs an owned room (throws on a loginless handle). Returns the
+     * handle (for ``handle.start({ all: true })``). Mirror of Python's ``offer_audio_capture``.
+     */
+    offerAudioCapture(opts?: {
+        maxSources?: number;
+    }): OfferedCapture;
+    private resolveEmbedSpace;
+    private resolveAnchorVector;
+    /**
+     * Handle ``embed.resolve`` requests from code-joined peers (e.g. a loginless Unity scene) — resolve
+     * named operand descriptors (``{ text }`` / ``{ concept, collection? }`` / ``{ vector }`` /
+     * ``{ asset, match_by? }``) to vectors in ONE embedding space, so a peer with no credentials can
+     * compare live signals against library concepts/text/assets. **The requester chooses the space**
+     * (omitted → the default text space). A per-anchor
+     * failure lands in ``errors`` without failing the others; a malformed / over-``maxAnchors`` request
+     * or a ``space`` outside ``spaces`` gets a whole-request ``{ error }``. Announces the discoverable
+     * ``embed-broker`` role — call before ``connect()``. Mirror of Python's ``offer_embeds``.
+     */
+    offerEmbeds(opts?: {
+        spaces?: string[];
+        maxAnchors?: number;
+    }): void;
+    /**
+     * Handle ``chat.generate`` requests from code-joined peers — a stateless chat completion (no history
+     * broker-side), so a loginless peer gets an LLM reply without its own credentials. Reply:
+     * ``{ text, model }``, or ``{ error }`` if ``messages`` is malformed / over the payload cap. The
+     * **broker** pins ``model`` (the requester cannot choose it — cost control); ``maxTokens`` caps each
+     * reply. Announces the discoverable ``chat-broker`` role — call before ``connect()``. Every peer
+     * holding the connect code can trigger a reply on **your** billing. Mirror of Python's ``offer_chat``.
+     */
+    offerChat(opts?: {
+        model?: string;
+        maxTokens?: number;
+    }): void;
+    private resolveAudioSpace;
+    private snippetStream;
+    /**
+     * Subscribe to the room's live ``audio.snippet`` stream and embed each ~10s window, yielding an
+     * {@link AudioVector} per snippet — a live vector of "what the room sounds like right now".
+     * Subscribing *is* the demand signal (announces the ``audio-snippet-consumer`` role, so a
+     * producer's default-off "Share audio clips" toggle actually captures). Break out of the
+     * ``for await`` loop to end it. Mirror of Python's ``audio_vectors``.
+     *
+     * ``space`` pins the search space snippets are labeled with (default: the deployment's default
+     * audio space, so a no-arg vector is comparable against library-derived vectors); ``model`` the
+     * embedding model (default: the resolved space's configured model). ``relay: true`` also relays
+     * each vector into the room as an ephemeral ``audio.vector`` signal — so a loginless code-joined
+     * peer can consume the live mood vector without credentials of its own. Needs an authenticated
+     * client to embed with (throws on a loginless handle); binary rides the WebSocket only.
+     */
+    audioVectors(opts?: {
+        space?: string;
+        model?: string;
+        relay?: boolean;
+    }): AsyncGenerator<AudioVector>;
+    private preflightConceptAnchors;
+    /**
+     * Fuse {@link audioVectors} with per-anchor ``library.compare`` scoring — a live "which anchor does
+     * the room sound like right now" signal. ``anchors`` maps a name to anything the ``by`` grammar
+     * accepts (a bare string / {@link "../by".Asset} / ``by.*`` marker), **or an array** of those (a
+     * few-shot category, scored as the mean of its top-``topN`` members' calibrated compare scores;
+     * default ``topN: 1`` — the nearest member wins). Each frame's anchors are scored concurrently.
+     *
+     * Each {@link ScoredAudio} carries the calibrated ``scores`` plus ``mix`` (normalized to sum 1,
+     * uniform when every score is 0 — gate on ``max(scores)`` for silence). No smoothing — ease the
+     * stream with a {@link ../decider.Decider}. ``relay: true`` forwards to {@link audioVectors} (it
+     * relays the raw ``audio.vector``, not the computed scores). Concept anchors are validated once up
+     * front (a typo raises before any frame); a mid-stream compare failure re-throws named by anchor.
+     * Mirror of Python's ``audio_scores``.
+     */
+    audioScores(anchors: Record<string, AnchorLike>, opts?: {
+        space?: string;
+        model?: string;
+        topN?: number;
+        relay?: boolean;
+    }): AsyncGenerator<ScoredAudio>;
+    /**
+     * The room's current presence roster as typed {@link Participant}s (merged ``roles`` / ``name`` /
+     * ``connectedAt`` as a ``Date``). Opens one short **observe** SSE stream, reads the roster off its
+     * first ``ready`` frame, and closes — a per-web-worker, best-effort snapshot (mirror of Python's
+     * ``participants()``). Rejects if the stream is refused (a 4xx — room deleted, or a bad code).
+     */
+    participants(): Promise<Participant[]>;
+    /**
+     * Is any current participant matching the given predicate connected? Sugar over
+     * {@link participants} (same best-effort per-worker caveat). Give at least one of ``role`` /
+     * ``name`` / ``identityPrefix`` — several are ANDed; ``role`` matches the merged roles, ``name``
+     * the announced name exactly, ``identityPrefix`` the identity's leading segment (a hosted Player
+     * announces ``player:web``, so ``{ identityPrefix: "player:" }`` is the launch-once guard). Throws
+     * if no predicate is given (mirror of Python's ``has()``).
+     */
+    has(pred: ParticipantPredicate): Promise<boolean>;
+    /** Play a sound (or several) on a layer — the one playback verb. Per-sound options (``effects``,
+     * ``spatial`` — including its optional ``distance`` attenuation — ``delay_seconds``, ``loop`` …)
+     * ride a hand-rolled track dict and pass through untouched. */
+    play(source: unknown, opts?: {
+        layer?: string;
+        mode?: "oneshot" | "queue";
+        transition?: "now" | "after_current" | "queued";
+        repeat?: boolean;
+        shuffle?: boolean;
+    }): Promise<void>;
+    /** Declare (or replace) the Player's layer set — idempotent. */
+    configureLayers(layers: Array<Record<string, unknown>>): Promise<void>;
+    /** Fade out and empty a layer — its queue and one-shots (omit ``layer`` → ``"default"``). */
+    clearLayer(opts?: {
+        layer?: string;
+        fadeOutMs?: number;
+    }): Promise<void>;
+    /** Fade out and empty **every** layer at once — "stop all audio" (the ``"*"`` wildcard). */
+    clearAll(opts?: {
+        fadeOutMs?: number;
+    }): Promise<void>;
+    /** Set (or ramp) a layer's effects, e.g. ``{ lowpass: { hz: 700 } }`` for a backroom muffle.
+     * ``lowpass`` / ``highpass`` / ``reverb`` / ``echo`` are all live (an absent implemented key ramps
+     * back to neutral); ``layer`` may be ``"*"`` to apply to every existing layer. */
+    setLayerEffects(layer: string, effects: Record<string, unknown>, opts?: {
+        fadeMs?: number;
+    }): Promise<void>;
+    /** Set (or ramp) a layer's HRTF position — placed whole-layer in 3D over ``fadeMs`` (default 50ms
+     * to avoid zipper noise, applied Player-side). ``z`` defaults to 0. ``distance`` opts into distance
+     * attenuation (``{ model, ref, max, rolloff }``); absent → direction-only. No ``"*"`` wildcard. */
+    setLayerPosition(layer: string, x: number, y: number, z?: number, opts?: {
+        fadeMs?: number;
+        distance?: Record<string, unknown>;
+    }): Promise<void>;
+    /** Pull the Player's current layer state (a broadcast request; first Player to reply wins). */
+    queryLayers(opts?: {
+        timeout?: number;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Subscribe to the Player's live layer state, invoking ``callback`` with each ``{ layers }``
+     * snapshot the Player pushes (every meaningful change + a ~1s heartbeat while playing). Demand-
+     * gated: the Player only broadcasts while a subscriber is present. Returns an unsubscribe function
+     * that sends ``layer.unsubscribe``.
+     */
+    watchLayers(callback: (layers: Record<string, unknown>) => void): () => void;
+    /** The hosted Player's launch URL for this room (``<base>/tools/player?code=<code>``). Pure. */
+    playerUrl(opts?: {
+        analysis?: boolean;
+        clips?: boolean;
+    }): string;
+    /**
+     * Show an image on the Viewer — the one display verb. Give exactly one of ``assetId`` (a stored
+     * asset) or ``url`` (any reachable image); passing both, or neither, throws. ``caption`` labels
+     * the frame; ``projection`` (``"flat"`` for a plain image, ``"360"`` for an equirectangular
+     * panorama) forces how the Viewer renders it — omit it and the Viewer's own default applies. See
+     * ``docs/reference/viewer-dialect.md``.
+     */
+    show(opts?: {
+        assetId?: string;
+        url?: string;
+        caption?: string;
+        projection?: "flat" | "360";
+    }): Promise<void>;
+    /** Clear the Viewer — blank the frame (the ``show.clear`` verb, empty body). */
+    clearView(): Promise<void>;
+    /** The hosted Viewer's launch URL for this room (``<base>/tools/viewer?code=<code>``). Pure. The
+     * Viewer defaults to auto-turn on; ``autoTurn`` bakes its persistent preference into the URL as
+     * ``autoturn=1``/``0`` (omitted → the Viewer's stored/default preference applies). */
+    viewerUrl(opts?: {
+        autoTurn?: boolean;
+    }): string;
+    /** The observation dashboard's launch URL (``<base>/tools/dashboard?code=<code>``). Pure — the
+     * dashboard takes only the connect code (mirror of Python's ``dashboard_url``). */
+    dashboardUrl(): string;
+    /** Open the observation dashboard for this room in a browser tab. Always opens — it does not check
+     * presence. Throws outside a browser (there is no tab to open). */
+    openDashboard(): void;
+    /** The Capture tool's launch URL for this room (``<base>/tools/capture?code=<code>``). Pure.
+     * ``name`` prefills the participant name field; ``captions`` / ``save`` pre-engage the "Live
+     * captions" / "Save recording" toggles (emitted only when truthy — else the tool's own default
+     * applies). Mirror of Python's ``capture_url``. */
+    captureUrl(opts?: {
+        name?: string;
+        captions?: boolean;
+        save?: boolean;
+    }): string;
+    /** Open the Capture tool for this room in a browser tab (see {@link captureUrl}). Always opens —
+     * it does not check presence. Throws outside a browser (there is no tab to open). */
+    openCapture(opts?: {
+        name?: string;
+        captions?: boolean;
+        save?: boolean;
+    }): void;
+    private toolBase;
+    private rest;
+    /** Rotate the connect code (owner only); updates ``connectCode`` and returns it. */
+    rotateCode(): Promise<string>;
+    /** Delete the room for good (its connect code dies with it). */
+    delete(): Promise<void>;
+    /** Disconnect the socket, stop dispatch, and fail any in-flight requests — the fire-and-forget
+     * teardown. Idempotent. The synchronous state (sockets closed, requests failed, listeners cleared)
+     * settles at once; the standing offers' async wind-down (**including finalizing their open
+     * recordings**) and the transcribers' stop run in the background. To *await* that finalize — so a
+     * process exit can't drop it — use {@link closeAndFinalize} / ``await using room``. */
+    close(): void;
+    /** Await the full teardown end-to-end — every recorder/transcriber stopped and every standing offer
+     * wound down **with its open recordings finalized** — mirroring Python's awaited ``async with room``
+     * exit. Idempotent; ``await using room`` calls this. Prefer it over {@link close} when the offers'
+     * finalize POSTs must land before the process moves on. */
+    closeAndFinalize(): Promise<void>;
+    private teardown;
+    [Symbol.dispose]: () => void;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}
+//# sourceMappingURL=room.d.ts.map

package/dist/rooms/room.d.ts.map

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