hci-atrium 0.3.1 → 0.4.0

package/dist/rooms/index.js

@@ -1,6 +1,6 @@
 /** The live rooms surface — the {@link Room} handle, its audio codec, and the loginless
  * {@link joinRoom} entry (no client needed, just a connect code). */
-import { DEFAULT_BASE_URL, readEnv } from "../env.js";
+import { resolveBaseUrl } from "../env.js";
 import { raiseForStatus } from "../errors.js";
 import { httpFetch } from "../http.js";
 import { Room } from "./room.js";
@@ -9,6 +9,7 @@ export { BrokerError, CAPTURE_OFFER_ROLE, CHAT_BROKER_ROLE, DEFAULT_CHAT_MAX_TOK
 export { AUDIO_ROLE, AUDIO_SIGNAL, decodeAudioFrame, encodeAudioFrame, isAudioFrame, } from "./codec.js";
 export { OfferedCapture } from "./offer-capture.js";
 export { OfferedTranscription } from "./offer-transcription.js";
+export { OwnedRoom } from "./owned-room.js";
 export { mergeRoles, parseParticipant, participantMatches, } from "./participant.js";
 export { Recorder } from "./recorder.js";
 export { Room, } from "./room.js";
@@ -22,7 +23,7 @@ export { TRANSCRIBER_SOURCE, Transcriber } from "./transcriber.js";
  * signals (but not manage the room — that needs the owner). Mirrors the Python SDK's ``join_room``.
  */
 export async function joinRoom(code, opts = {}) {
-    const baseUrl = (opts.baseUrl ?? readEnv("ATRIUM_BASE_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const baseUrl = resolveBaseUrl(opts.baseUrl);
     const res = await httpFetch(`${baseUrl}/v1/rooms/resolve?code=${encodeURIComponent(code)}`);
     if (!res.ok)
         await raiseForStatus(res);
@@ -36,7 +37,7 @@ export async function joinRoom(code, opts = {}) {
         requestTimeout: opts.requestTimeout,
         reconnect: opts.reconnect,
         transport: opts.transport,
-        WebSocketCtor: opts.WebSocketCtor,
+        webSocketCtor: opts.webSocketCtor,
         fetchImpl: opts.fetchImpl,
         signal: opts.signal,
     };

package/dist/rooms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rooms/index.ts"],"names":[],"mappings":"AAAA;qEACqE;AAErE,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,EAAE,IAAI,EAAyC,MAAM,WAAW,CAAA;AAIvE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAEL,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,UAAU,EACV,YAAY,EAOZ,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAA+C,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAChG,OAAO,EAAE,oBAAoB,EAA+B,MAAM,0BAA0B,CAAA;AAC5F,OAAO,EACL,UAAU,EAGV,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,QAAQ,EAA2B,MAAM,eAAe,CAAA;AACjE,OAAO,EAIL,IAAI,GAML,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EAEvB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAkB,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC7E,OAAO,EAEL,iBAAiB,EAEjB,cAAc,GACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAwB,MAAM,kBAAkB,CAAA;AA0BxF;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,IAAY,EAAE,OAAwB,EAAE;IACrE,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,iBAAiB,CAAC,IAAI,gBAAgB,CAAC,CAAC,OAAO,CACtF,MAAM,EACN,EAAE,CACH,CAAA;IACD,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,GAAG,OAAO,0BAA0B,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAC3F,IAAI,CAAC,GAAG,CAAC,EAAE;QAAE,MAAM,cAAc,CAAC,GAAG,CAAC,CAAA;IACtC,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAA2C,CAAA;IACzE,MAAM,IAAI,GAAa;QACrB,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACnB,WAAW,EAAE,IAAI,CAAC,YAAY,IAAI,IAAI;QACtC,OAAO;QACP,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,MAAM,EAAE,IAAI,CAAC,MAAM;KACpB,CAAA;IACD,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAA;AACvB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rooms/index.ts"],"names":[],"mappings":"AAAA;qEACqE;AAErE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,EAAE,IAAI,EAAyC,MAAM,WAAW,CAAA;AAIvE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAEL,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,UAAU,EACV,YAAY,EAOZ,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAA+C,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAChG,OAAO,EAAE,oBAAoB,EAA+B,MAAM,0BAA0B,CAAA;AAC5F,OAAO,EAAE,SAAS,EAAsB,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EACL,UAAU,EAGV,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,QAAQ,EAA2B,MAAM,eAAe,CAAA;AACjE,OAAO,EAIL,IAAI,GAML,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EAEvB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAkB,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC7E,OAAO,EAEL,iBAAiB,EAEjB,cAAc,GACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAwB,MAAM,kBAAkB,CAAA;AA2BxF;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,IAAY,EAAE,OAAwB,EAAE;IACrE,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC5C,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,GAAG,OAAO,0BAA0B,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAC3F,IAAI,CAAC,GAAG,CAAC,EAAE;QAAE,MAAM,cAAc,CAAC,GAAG,CAAC,CAAA;IACtC,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAA2C,CAAA;IACzE,MAAM,IAAI,GAAa;QACrB,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACnB,WAAW,EAAE,IAAI,CAAC,YAAY,IAAI,IAAI;QACtC,OAAO;QACP,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,MAAM,EAAE,IAAI,CAAC,MAAM;KACpB,CAAA;IACD,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAA;AACvB,CAAC"}

package/dist/rooms/offer-transcription.d.ts

@@ -6,7 +6,7 @@
  * Engage is **sender-scoped** (see {@link ./armed-set.ArmedSet}): only armed sources are transcribed
  * — an unarmed source's frames are dropped at the demux (no engine spawns). While engaged it
  * subscribes the room's ``audio.snippet`` stream, demuxes frames per source, and runs one
- * transcription engine per source (the same engine as {@link ./room.Room.transcribe}), stamping each
+ * transcription engine per source (the same engine as {@link ./owned-room.OwnedRoom.transcribe}), stamping each
  * ``transcript.*`` signal's payload with the source's connection id and roster-resolved
  * ``source_name``. Up to ``maxSources`` sources; a departed source's engine is reaped promptly.
  */

package/dist/rooms/offer-transcription.js

@@ -6,7 +6,7 @@
  * Engage is **sender-scoped** (see {@link ./armed-set.ArmedSet}): only armed sources are transcribed
  * — an unarmed source's frames are dropped at the demux (no engine spawns). While engaged it
  * subscribes the room's ``audio.snippet`` stream, demuxes frames per source, and runs one
- * transcription engine per source (the same engine as {@link ./room.Room.transcribe}), stamping each
+ * transcription engine per source (the same engine as {@link ./owned-room.OwnedRoom.transcribe}), stamping each
  * ``transcript.*`` signal's payload with the source's connection id and roster-resolved
  * ``source_name``. Up to ``maxSources`` sources; a departed source's engine is reaped promptly.
  */

package/dist/rooms/owned-room.d.ts

@@ -0,0 +1,251 @@
+/**
+ * The **owned** room handle — {@link ./room.Room} plus every surface that needs the account
+ * credential behind it. Returned by ``client.rooms.open`` / ``.get`` / ``.list``, which inject the
+ * authenticated REST caller and the client slice this class is built on.
+ *
+ * The split is deliberate: a loginless ``joinRoom(code)`` handle is a plain {@link ./room.Room}, so
+ * the members here are not merely guarded at runtime — they are absent from its type. Everything on
+ * this class assumes a credential and calls it directly ({@link OwnedRoomDeps} makes ``rest`` /
+ * ``client`` required), so nothing here needs a runtime credential guard.
+ *
+ * Durable & reactive: {@link OwnedRoom.record} bridges the room into a session over an SSE-observe
+ * {@link ./recorder.Recorder} (a room stores nothing itself, so durable capture rides the observe
+ * stream); {@link OwnedRoom.audioVectors} embeds the live snippet stream and
+ * {@link OwnedRoom.audioScores} fuses it against named anchors for a {@link ../decider.Decider};
+ * the standing offers and capability brokers serve code-joined peers on your credential.
+ */
+import { type AnchorLike } from "../by.js";
+import { Dashboard, type DashboardOptions } from "../dash.js";
+import type { Session, Transcript } from "../models.js";
+import type { ShapedRequest } from "../shaping/index.js";
+import { RoomTrace } from "../trace.js";
+import { OfferedCapture } from "./offer-capture.js";
+import { OfferedTranscription } from "./offer-transcription.js";
+import { Recorder } from "./recorder.js";
+import { type AudioVector, Room, type RoomAudioClient, type RoomDeps, type ScoredAudio } from "./room.js";
+import { Transcriber } from "./transcriber.js";
+/** {@link RoomDeps} plus the account credential an {@link OwnedRoom} is defined by — both required,
+ * which is what lets this class call them without a guard. */
+export interface OwnedRoomDeps extends RoomDeps {
+    /** Authenticated REST caller for management + the durable writes (rotate / delete / signal POST). */
+    rest: (req: ShapedRequest) => Promise<unknown>;
+    /** The authenticated client's embed / chat / compare / transcribe slice. */
+    client: RoomAudioClient;
+}
+export declare class OwnedRoom extends Room {
+    protected readonly deps: OwnedRoomDeps;
+    private readonly recorderListeners;
+    constructor(deps: OwnedRoomDeps);
+    /**
+     * 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}).
+     */
+    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``.
+     */
+    transcribe(opts?: {
+        model?: string;
+        language?: string;
+    }): Transcriber;
+    /**
+     * Subscribe to the room's live ``audio.snippet`` stream and transcribe it, yielding a
+     * {@link ../models.Transcript} per finalized sentence — the speech-to-text sibling of
+     * {@link audioVectors}, and the *raw* counterpart of the {@link transcribe} broker (which publishes
+     * ``transcript.*`` signals for every peer instead of handing you the stream).
+     *
+     * 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 abort ``signal`` — to end the subscription and close the socket.
+     *
+     * Snippets run through the same engine as {@link ../atrium.Atrium.transcribeLive}: true streaming
+     * (per-sentence finals, plus revisable partials with ``partials``) when the backend's live route is
+     * reachable, degrading silently to per-clip batch transcription otherwise (finals only).
+     * Transcription runs on *your* credentials/compute — a rejected credential raises rather than
+     * falling back.
+     *
+     * The two paths differ in one detail (mirror of Python's ``audio_transcripts``): on the **fallback**
+     * path each transcript carries its source frame's ``sequence`` / ``window_seconds`` under
+     * ``transcript.raw.snippet`` (a cheap ordering/correlation handle) and the clip's format comes from
+     * that frame's own MIME type; on the **streaming** path transcripts are per-sentence, so there is no
+     * 1:1 snippet correlation and ``raw.snippet`` is omitted (``raw`` carries ``start`` / ``end``).
+     */
+    audioTranscripts(opts?: {
+        model?: string;
+        language?: string;
+        partials?: boolean;
+        skipEmpty?: boolean;
+        signal?: AbortSignal;
+    }): AsyncGenerator<Transcript>;
+    private snippetBytesFor;
+    private requirePreConnect;
+    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()``.
+     * 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()``. 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;
+    /**
+     * Build the host-side {@link ../dash.Dashboard} for this room — the live observation-dashboard
+     * state an app holds as a grid of tiles. It answers each joining ``/tools/dashboard`` with a full
+     * ``dash.snapshot`` and broadcasts ``dash.delta`` patches as things change, all **ephemeral** (the
+     * room stores nothing — the durable record is the session).
+     *
+     * Prefer this over ``new Dashboard(room)``: it publishes over the REST ``/signal`` POST, which
+     * preserves the dialect's ephemerality (the WS inbound path forces ``ephemeral: false``). Mirror of
+     * Python's ``Dashboard(room)``.
+     */
+    dashboard(opts?: DashboardOptions): Dashboard;
+    /**
+     * Mirror the SDK's own activity into this room as ``trace.*`` signals — one line turns it on. The
+     * operation folds into the signal type (``label`` still rides the payload), and ephemerality is
+     * per-signal (see {@link ../trace.isTraceEphemeral}). While tracing:
+     *
+     * * **library/model calls** made through the same client (``search`` / ``searchByExamples`` /
+     *   ``enrich`` / ``play`` / ``chat``) surface a ``trace.<label>`` (``trace.library.search`` /
+     *   ``trace.chat`` / ``trace.play``) — a glanceable summary (``"rain" → 8 hits (top: Forest Rain
+     *   0.83)``) plus a capped detail (top-N results, never full payloads);
+     * * **SDK-internal state** — a recorder start/stop (with its session + event count), a transcriber
+     *   start/stop, a standing offer's armed/active roster — surfaces a ``trace.state.<label>``.
+     *
+     * Default OFF (it broadcasts app internals to anyone with the code, and it's noise on the happy
+     * path). Returns a handle: ``const t = room.trace()`` then ``t.stop()``, or ``using t =
+     * room.trace()`` for a scope; stopped when the room closes. A trace failure never breaks the traced
+     * call. ``play`` and the state seam are scoped to **this** room; client-wide calls mirror into every
+     * armed room. Mirror of Python's ``room.trace()``.
+     */
+    trace(): RoomTrace;
+    private traceState;
+    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. 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>;
+    /** 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>;
+    protected teardown(): Promise<void>;
+}
+//# sourceMappingURL=owned-room.d.ts.map

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

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