hci-atrium 0.3.0 → 0.4.0

package/dist/atrium.js

@@ -4,13 +4,13 @@
 import { Auth } from "./auth.js";
 import { seedAssetId, toOperand } from "./by.js";
 import { DirectEndpoint, DirectRegistry, directFetch, parseModelNames, } from "./direct.js";
-import { DEFAULT_BASE_URL, readEnv } from "./env.js";
+import { DEFAULT_BASE_URL, readEnv, resolveBaseUrl } from "./env.js";
 import { APIError, AtriumError, AuthError, InvalidArgumentError, raiseForStatus } from "./errors.js";
 import { httpFetch } from "./http.js";
 import { parseAsset, parseAssetPage, parseAssetVector, parseChatReply, parseCompareResult, parseEmbedding, parseIndexEntry, parseRoom, parseSearchByExamplesHit, parseSearchHit, parseSegment, parseSession, parseSessionEvent, parseSessionEventRow, parseSessionInfo, parseSourceInfo, parseSourceSearchResult, parseSpace, parseSurvey, parseSurveyResponse, parseSurveyTemplate, parseTagDefinition, parseTranscript, } from "./models.js";
-import { Room } from "./rooms/index.js";
+import { OwnedRoom, Room, } from "./rooms/index.js";
 import { sseFrames } from "./rooms/sse.js";
-import { buildAssetGet, buildAssetIndex, buildAssetList, buildAssetSegments, buildAssetVectors, buildBulkVectors, buildChat, buildCompare, buildEmbed, buildEnrich, buildProjectFileUpload, buildRoomOpen, buildSearch, buildSearchByExamples, buildSessionEvent, buildSessionEvents, buildSessionExport, buildSessionExportBundle, buildSessionStart, buildSessionsList, buildSourceImport, buildSourcesSearch, buildSurveyResponses, buildSurveyStart, buildTagGet, buildTagsList, buildTemplateCreate, buildTemplateDefault, buildTemplateGet, buildTemplatesList, buildTemplateVersion, buildTranscribe, buildUpload, chatBody, distinctExportIds, isZodSchema, JSON_OBJECT, repairMessages, resolveImportTarget, responseFormatParam, sameJsonBody, structuredError, tryParse, } from "./shaping/index.js";
+import { buildAdd, buildAssetGet, buildAssetIndex, buildAssetList, buildAssetSegments, buildAssetVectors, buildBulkVectors, buildChat, buildCompare, buildEmbed, buildEnrich, buildProjectFileUpload, buildRoomOpen, buildSearch, buildSearchByExamples, buildSessionEvent, buildSessionEvents, buildSessionExport, buildSessionExportBundle, buildSessionStart, buildSessionsList, buildSourceImport, buildSourcesSearch, buildSurveyResponses, buildSurveyStart, buildTagGet, buildTagsList, buildTemplateCreate, buildTemplateDefault, buildTemplateGet, buildTemplatesList, buildTemplateVersion, buildTranscribe, chatBody, distinctExportIds, isZodSchema, JSON_OBJECT, repairMessages, resolveImportTarget, responseFormatParam, sameJsonBody, structuredError, tryParse, } from "./shaping/index.js";
 import { buildRoomResolve } from "./shaping/rooms.js";
 import { PkceStore, TokenStore } from "./storage.js";
 import { parseToolArguments, readToolCalls, toolSchema } from "./tools.js";
@@ -71,14 +71,6 @@ function bytesToBase64(bytes) {
     }
     return btoa(binary);
 }
-/** The OpenAI passthrough params of a {@link ChatOptions} — everything the SDK doesn't own itself. */
-function stripChatOptions(opts) {
-    const params = { ...opts };
-    for (const key of ["model", "responseFormat", "strictParams", "signal", "stream"]) {
-        delete params[key];
-    }
-    return params;
-}
 /**
  * Yield the content deltas of a streamed chat completion. The wire is SSE — ``data:`` frames of
  * OpenAI chunk JSON, terminated by ``data: [DONE]`` — read through the room transport's
@@ -159,7 +151,7 @@ export class Atrium {
     /** Model name → OpenAI-compatible endpoint; consulted by ``chat`` / ``agent`` only. */
     direct;
     constructor(opts = {}) {
-        const baseUrl = (opts.baseUrl ?? readEnv("ATRIUM_BASE_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        const baseUrl = resolveBaseUrl(opts.baseUrl);
         this.baseUrl = baseUrl;
         this.clientId = opts.clientId ?? readEnv("ATRIUM_CLIENT_ID");
         this.apiKey = opts.apiKey ?? readEnv("ATRIUM_API_KEY");
@@ -280,28 +272,46 @@ export class Atrium {
         }
     }
     chat(messages, opts = {}) {
-        if (opts.stream) {
-            if (isZodSchema(opts.responseFormat)) {
-                throw new InvalidArgumentError("chat(responseFormat: <Zod schema>) cannot be combined with stream: true — structured " +
-                    "output validates a complete reply");
-            }
-            const chunks = this.chatStream(messages, opts);
-            // Python's decorator emits the trace when the generator is handed back (nothing is consumed
-            // yet), so a streamed call has no reply preview and a ~0 duration. Mirror that rather than
-            // deferring the emit until the stream drains — a `trace.chat` should appear when the call is
-            // made. Fire-and-forget: `traced` swallows its own failures and the fn resolves immediately.
-            void traced(this.traceSinks, "chat", { model: opts.model }, summarizeChat, async () => chunks);
-            return chunks;
-        }
         // One logical call, one `trace.chat` — the structured path recurses through the UNTRACED
         // `chatOnce` below, which is how TS gets Python's re-entrancy guard for free.
         return traced(this.traceSinks, "chat", { model: opts.model }, summarizeChat, () => isZodSchema(opts.responseFormat)
             ? this.chatParse(messages, opts.responseFormat, opts)
             : this.chatOnce(messages, opts));
     }
-    /** The chat body for one completion: the caller's passthrough params plus the SDK-owned keys. */
+    /**
+     * Stream a chat completion's content deltas — an ``AsyncIterable<string>`` returned
+     * **synchronously**, so there is nothing to ``await`` before the ``for await`` loop.
+     *
+     * The streaming sibling of {@link chat}, and its own method rather than a ``stream: true`` flag:
+     * the return type differs completely, and a flag that changes it makes every call site narrow a
+     * union the caller already knows the answer to. Structured output has no meaning here (a schema
+     * validates a *complete* reply) — that's {@link chat}. Works the same on a direct endpoint.
+     */
+    chatStream(messages, opts = {}) {
+        const chunks = this.streamDeltas(messages, opts);
+        // Python's decorator emits the trace when the generator is handed back (nothing is consumed
+        // yet), so a streamed call has no reply preview and a ~0 duration. Mirror that rather than
+        // deferring the emit until the stream drains — a `trace.chat` should appear when the call is
+        // made. Fire-and-forget: `traced` swallows its own failures and the fn resolves immediately.
+        void traced(this.traceSinks, "chat", { model: opts.model }, summarizeChat, async () => chunks);
+        return chunks;
+    }
+    /**
+     * The chat body's params for one completion: the caller's passthrough bag plus the SDK-owned keys
+     * (applied last, so they win a collision).
+     *
+     * ``stream`` **throws** — it would swap the response for an SSE body that ``chat`` then parses as
+     * JSON, so the only honest answer names {@link chatStream}. ``messages`` is dropped: the messages
+     * argument is the messages, and a second copy in the bag can only be an accident.
+     */
     chatParams(opts) {
-        const p = stripChatOptions(opts);
+        const p = { ...opts.params };
+        if ("stream" in p) {
+            throw new InvalidArgumentError("chat params: `stream` is not a passthrough key — the SDK owns it. For token deltas call " +
+                "atrium.chatStream(messages, opts), which returns an AsyncIterable<string> and sets it " +
+                "itself; chat() always resolves one complete reply");
+        }
+        delete p.messages;
         if (opts.responseFormat !== undefined) {
             p.response_format = opts.responseFormat;
         }
@@ -323,7 +333,7 @@ export class Atrium {
     }
     /** Content deltas of a streamed completion (SSE, ``[DONE]``-terminated) — the Atrium route or,
      * for a registered model, the direct endpoint. Mirror of Python's ``_chat_stream``. */
-    async *chatStream(messages, opts) {
+    async *streamDeltas(messages, opts) {
         const body = chatBody(messages, opts.model, { ...this.chatParams(opts), stream: true });
         const endpoint = this.direct.resolve(opts.model);
         const res = endpoint
@@ -359,7 +369,7 @@ export class Atrium {
         throw structuredError(schema.constructor.name, second.content, detail);
     }
     async agent(prompt, opts) {
-        const { tools, model, maxTurns = 6, responseFormat, signal } = opts;
+        const { tools, model, maxTurns = 6, responseFormat, signal, strictParams } = opts;
         if (responseFormat !== undefined && !isZodSchema(responseFormat)) {
             // Unlike chat(), a raw dict has nowhere sensible to go: json-mode conflicts with the
             // tool-calling turns, so forwarding it would break the loop and ignoring it would silently do
@@ -367,15 +377,18 @@ export class Atrium {
             throw new InvalidArgumentError("agent(responseFormat) takes a Zod schema (it structures the final answer); a json-mode " +
                 "dict isn't applied to the tool-calling turns");
         }
-        const params = { ...opts };
-        for (const key of ["tools", "model", "maxTurns", "responseFormat", "signal"])
-            delete params[key];
+        const params = { ...opts.params };
         const byName = new Map(tools.map((tool) => [tool.name, tool]));
         const schemas = tools.map(toolSchema);
         const messages = [{ role: "user", content: prompt }];
         let reply = { content: "", model: "", raw: {} };
         for (let turn = 0; turn < maxTurns; turn++) {
-            reply = await this.chat(messages, { model, tools: schemas, signal, ...params });
+            reply = await this.chat(messages, {
+                model,
+                signal,
+                strictParams,
+                params: { ...params, tools: schemas },
+            });
             const choices = reply.raw.choices;
             const message = (Array.isArray(choices) ? choices[0] : undefined);
             const assistant = message?.message;
@@ -394,7 +407,12 @@ export class Atrium {
         }
         if (isZodSchema(responseFormat)) {
             // Structure the FINAL answer only — json-mode conflicts with the tool-calling turns.
-            return this.parseOrRepair(messages, reply, responseFormat, { model, signal, ...params });
+            return this.parseOrRepair(messages, reply, responseFormat, {
+                model,
+                signal,
+                strictParams,
+                params,
+            });
         }
         return reply;
     }
@@ -629,6 +647,25 @@ if (typeof Symbol.asyncDispose === "symbol") {
     };
 }
 // --- namespaces ----------------------------------------------------------------------------------
+/**
+ * Refuse an operand handed to ``search`` where its options object belongs.
+ *
+ * ``SearchOptions`` has no required field, so TypeScript's weak-type check is the only thing
+ * standing between ``search(hit)`` and a compile error — and an {@link Asset} / {@link SearchHit} /
+ * ``by.*`` operand *does* share a property name with it, which satisfies that check. The call would
+ * then search for the empty string with no filters: a full-library dump, silently. Runtime is where
+ * this can still be caught, so it is caught here, naming the fix.
+ */
+function rejectOperandAsSearchOptions(opts) {
+    const o = opts;
+    const isAsset = typeof o.id === "string" && (o.facts !== undefined || o.modality !== undefined);
+    const isHit = o.asset !== undefined && typeof o.score === "number";
+    const isOperand = typeof o.kind === "string";
+    if (isAsset || isHit || isOperand) {
+        throw new InvalidArgumentError("search(): the object form takes search OPTIONS, not the thing to search by — pass " +
+            "{ like: hit } (or { like: asset }, { like: id }) instead of the operand itself");
+    }
+}
 function likeSourceId(like) {
     if (typeof like === "string") {
         return like;
@@ -641,6 +678,28 @@ export class Library {
     constructor(c) {
         this.c = c;
     }
+    /**
+     * Add an asset to the library (``POST /v1/assets``); it indexes in the background — the front door
+     * for putting something in (mirror of Python's ``library.add``).
+     *
+     * Pass a ``file`` to upload it (a ``Blob``/``File`` or a URL string — never a filesystem path, the
+     * core is browser-safe), or omit it and pass only a ``description`` to create a **fileless** asset
+     * whose description *is* the content (the web UI's "Add other" — a mood note, a data-only record).
+     * One of the two is required. ``modality`` is a free-form label for search/display only; for a file
+     * the server derives the real ``contentKind`` from the bytes, and a fileless asset defaults to
+     * ``"other"``. {@link Assets.upload} is the file-only twin.
+     */
+    async add(opts = {}) {
+        const { collection } = this.c.scope(undefined, opts.collection);
+        const req = buildAdd({
+            file: opts.file,
+            modality: opts.modality,
+            description: opts.description,
+            collection,
+        });
+        const data = await this.c.request(req, opts.signal);
+        return parseAsset(data, this.c.baseUrl, this.c.assetBinder);
+    }
     /** List the searchable embedding spaces (``GET /v1/library/spaces``). */
     async spaces(opts = {}) {
         const data = await this.c.request({ method: "GET", path: "/v1/library/spaces" }, opts.signal);
@@ -660,8 +719,19 @@ export class Library {
         return (spaces.find((s) => s.defaultModalities.includes(modality)) ??
             spaces.find((s) => s.modalities.includes(modality)));
     }
-    /** Semantic search — by text, an example asset (``like``), a media file, or a raw ``vector``. */
-    async search(query = "", opts = {}) {
+    async search(queryOrOpts = "", maybeOpts = {}) {
+        // String-vs-object discriminant: only the string form takes a second argument.
+        const isStringForm = typeof queryOrOpts === "string";
+        const opts = isStringForm ? maybeOpts : queryOrOpts;
+        if (!isStringForm) {
+            // `SearchOptions` is all-optional, so an Asset / SearchHit / `by.*` operand is weak-type
+            // compatible with it and would silently search for nothing. Name the fix instead.
+            rejectOperandAsSearchOptions(opts);
+        }
+        if (isStringForm && opts.query !== undefined) {
+            throw new InvalidArgumentError("search(): pass the text either as the first argument or as opts.query, not both");
+        }
+        const query = isStringForm ? queryOrOpts : (opts.query ?? "");
         const { project, collection } = this.c.scope(opts.project, opts.collection);
         const media = opts.image ?? opts.audio ?? opts.video;
         const space = opts.space !== undefined ? await this.c.resolveSpace(opts.space) : undefined;
@@ -847,17 +917,10 @@ export class Assets {
         const data = await this.c.request(buildAssetIndex(likeSourceId(assetOrId)));
         return (Array.isArray(data) ? data : []).map(parseIndexEntry);
     }
-    /** Upload a file to the library (``POST /v1/assets``); it indexes in the background. */
-    async upload(file, opts = {}) {
-        const { collection } = this.c.scope(undefined, opts.collection);
-        const req = buildUpload({
-            file,
-            modality: opts.modality,
-            description: opts.description,
-            collection,
-        });
-        const data = await this.c.request(req, opts.signal);
-        return parseAsset(data, this.c.baseUrl, this.c.assetBinder);
+    /** Upload a file to the library (``POST /v1/assets``); it indexes in the background. The file-only
+     * twin of {@link Library.add}, which it delegates to — same request, same result. */
+    upload(file, opts = {}) {
+        return this.c.library.add({ ...opts, file });
     }
 }
 /** External sources — search several providers at once, then import what you pick. */
@@ -883,9 +946,10 @@ export class Sources {
         const data = await this.c.request(req, opts.signal);
         return parseSourceSearchResult(data);
     }
-    /** Import one candidate into the shared library (``POST …/{source}/import``). */
-    async import(opts) {
-        const [sourceId, externalId] = resolveImportTarget(opts.candidate, opts.sourceId, opts.externalId);
+    /** Import one candidate into the shared library (``POST …/{source}/import``) — ``target`` is a
+     * {@link Candidate} from {@link search}, or an explicit ``{ sourceId, externalId }`` pair. */
+    async import(target, opts = {}) {
+        const [sourceId, externalId] = resolveImportTarget(target);
         const req = buildSourceImport({
             sourceId,
             externalId,
@@ -896,6 +960,26 @@ export class Sources {
         return parseAsset(data, this.c.baseUrl, this.c.assetBinder);
     }
 }
+/**
+ * Refuse the pre-0.4 options bag passed where the event payload now goes.
+ *
+ * ``{ payload: {...}, source: "app" }`` is a perfectly valid ``Record<string, unknown>``, so the old
+ * call shape type-checks as the new third argument and would be logged verbatim — a corrupted event,
+ * silently. It is only ambiguous in theory: a real payload carrying a ``payload`` key alongside
+ * anything other than ``source`` / ``via`` passes untouched.
+ */
+function rejectLegacyEventBag(payload) {
+    if (!payload)
+        return;
+    const nested = payload.payload;
+    if (!nested || typeof nested !== "object")
+        return;
+    const rest = Object.keys(payload).filter((key) => key !== "payload");
+    if (rest.every((key) => key === "source" || key === "via")) {
+        throw new InvalidArgumentError("session event: this looks like the pre-0.4 options bag — pass the event payload directly " +
+            "(sessions.event(id, type, payload)); source/via ride the 4th argument");
+    }
+}
 /** Start / resume sessions and append to their durable log. */
 export class Sessions {
     c;
@@ -912,14 +996,14 @@ export class Sessions {
             condition: opts.condition,
             meta: opts.meta,
         });
-        return parseSession(await this.c.request(req, opts.signal));
+        return parseSession(await this.c.request(req, opts.signal), this);
     }
     /** Resume an existing session by id (``GET /v1/sessions/{id}``) — the live {@link Session} handle
      * for continued logging. For a read-only analysis view use {@link get}, which GETs the same route
      * but returns a {@link SessionInfo} read model. */
     async resume(sessionId, opts = {}) {
         const data = await this.c.request({ method: "GET", path: `/v1/sessions/${sessionId}` }, opts.signal);
-        return parseSession(data);
+        return parseSession(data, this);
     }
     /** List a project's sessions, newest first (``GET /v1/sessions``) — the read model. No ``project``
      * → the client's default project. ``phase`` (a string or list) filters by study phase; the empty
@@ -966,11 +1050,14 @@ export class Sessions {
         const req = buildSessionExportBundle(distinctExportIds(ids));
         return this.c.requestBytes(req, opts.signal);
     }
-    /** Append a durable event to a session's log (``POST /v1/sessions/{id}/events``). */
-    async event(sessionId, type, opts = {}) {
+    /** Append a durable event to a session's log (``POST /v1/sessions/{id}/events``) — the id-based
+     * form. A {@link Session} handle from {@link start} / {@link resume} carries the bound
+     * ``session.event(type, payload?)``, which is the same call with the id threaded for you. */
+    async event(sessionId, type, payload, opts = {}) {
+        rejectLegacyEventBag(payload);
         const req = buildSessionEvent(sessionId, {
             type,
-            payload: opts.payload,
+            payload,
             source: opts.source,
             via: opts.via,
         });
@@ -1009,9 +1096,11 @@ export class Surveys {
     /**
      * Start a survey on a session: creates the data object (pinning the template's current version —
      * or the project's DEFAULT template when ``template`` is omitted) and returns the handle with its
-     * once-only token.
+     * once-only token. Options-only — ``start({ template: "post-study", into: session })``, or just
+     * ``start({ into: session })`` for the default template.
      */
-    async start(template, opts) {
+    async start(opts) {
+        const { template } = opts;
         const sessionId = typeof opts.into === "string" ? opts.into : opts.into.id;
         const req = buildSurveyStart(sessionId, {
             name: opts.name ?? template ?? "survey",
@@ -1111,67 +1200,83 @@ export class Surveys {
         };
     }
 }
-/** Open / fetch / join rooms — each returns a live {@link Room} handle (connect, send, on, request,
- * player controls, audio signals). ``connect()`` (called for you by any wire method) opens the socket. */
+/**
+ * Open / fetch / join rooms. ``open`` / ``get`` / ``list`` return an {@link OwnedRoom} — the live
+ * handle *plus* the host-side surfaces the account credential unlocks (``record`` / ``transcribe`` /
+ * ``audioVectors`` / ``dashboard`` / ``trace`` / the standing offers / ``rotateCode`` / ``delete``).
+ * ``join(code)`` returns a plain {@link Room}: a code grants live transport, not the account, so the
+ * host-side members are absent from its **type** rather than throwing at runtime.
+ * ``connect()`` (called for you by any wire method) opens the socket.
+ */
 export class Rooms {
     c;
     constructor(c) {
         this.c = c;
     }
-    wrap(info, live, participant) {
-        return new Room({
+    /** The participant deps every handle gets — the live-connection knobs, no credential. */
+    liveDeps(info, live) {
+        return {
             id: info.id,
             connectCode: info.connectCode,
             name: info.name,
             projectId: info.projectId,
             baseUrl: this.c.baseUrl,
-            // A participant (join-by-code) can't manage the room, nor embed (no credentials of its own);
-            // omit the REST caller and the embedding client for it.
-            rest: participant ? undefined : (req) => this.c.request(req),
-            client: participant
-                ? undefined
-                : {
-                    embed: (opts) => this.c.embed(opts),
-                    chat: (messages, o) => this.c.chat(messages, o),
-                    library: this.c.library,
-                    request: (req) => this.c.request(req),
-                    transcribeStream: (clips, o) => this.c.transcribeStream(clips, o),
-                    transcribe: (audio, o) => this.c.transcribe(audio, o),
-                    // The client's shared sink list — `room.trace()` registers on it, so the client's own
-                    // library/model calls mirror into this room.
-                    traceSinks: this.c.traceSinks,
-                },
             identity: live.identity,
             announce: live.announce,
             requestTimeout: live.requestTimeout,
             reconnect: live.reconnect,
             transport: live.transport,
-            WebSocketCtor: live.WebSocketCtor,
+            webSocketCtor: live.webSocketCtor,
             fetchImpl: live.fetchImpl,
             signal: live.signal,
+        };
+    }
+    /** The owned handle: the participant deps plus this client's REST caller and capability slice. */
+    own(info, live) {
+        return new OwnedRoom({
+            ...this.liveDeps(info, live),
+            rest: (req) => this.c.request(req),
+            client: {
+                embed: (opts) => this.c.embed(opts),
+                chat: (messages, o) => this.c.chat(messages, o),
+                library: this.c.library,
+                request: (req) => this.c.request(req),
+                transcribeStream: (clips, o) => this.c.transcribeStream(clips, o),
+                transcribe: (audio, o) => this.c.transcribe(audio, o),
+                // The client's shared sink list — `room.trace()` registers on it, so the client's own
+                // library/model calls mirror into this room.
+                traceSinks: this.c.traceSinks,
+            },
         });
     }
-    /** Open a room (``POST /v1/rooms``) and return a live handle. */
+    /** Open a room (``POST /v1/rooms``) and return a live owned handle. */
     async open(opts = {}) {
         const { project } = this.c.scope(opts.project, undefined);
         const req = buildRoomOpen({ name: opts.name, project, embeddingSpace: opts.embeddingSpace });
-        return this.wrap(parseRoom(await this.c.request(req, opts.signal)), opts, false);
+        return this.own(parseRoom(await this.c.request(req, opts.signal)), opts);
     }
-    /** Fetch a room by id (``GET /v1/rooms/{id}``) and return a live handle. */
+    /** Fetch a room by id (``GET /v1/rooms/{id}``) and return a live owned handle. */
     async get(roomId, opts = {}) {
         const data = await this.c.request({ method: "GET", path: `/v1/rooms/${roomId}` }, opts.signal);
-        return this.wrap(parseRoom(data), opts, false);
+        return this.own(parseRoom(data), opts);
     }
-    /** List the rooms you can see (``GET /v1/rooms``) as live handles. */
+    /** List the rooms you can see (``GET /v1/rooms``) as live owned handles. */
     async list(opts = {}) {
         const data = await this.c.request({ method: "GET", path: "/v1/rooms" }, opts.signal);
-        return (Array.isArray(data) ? data : []).map((d) => this.wrap(parseRoom(d), {}, false));
+        return (Array.isArray(data) ? data : []).map((d) => this.own(parseRoom(d), {}));
     }
-    /** Join a room by its connect code (``GET /v1/rooms/resolve``) — a participant handle that can
-     * ``send`` / ``on`` / ``request`` / play / consume audio, but not manage the room. */
+    /**
+     * Join a room by its connect code (``GET /v1/rooms/resolve``) — a **participant** handle that can
+     * ``send`` / ``on`` / ``request`` / play / consume audio, but not manage the room.
+     *
+     * Deliberately a {@link Room}, not an {@link OwnedRoom}, even though the resolve call itself is
+     * authenticated: a join-by-code handle is built without the REST caller and the capability slice,
+     * so the host-side surfaces would throw. The type says so instead. Need them? The room is yours —
+     * use {@link get} with its id.
+     */
     async join(code, opts = {}) {
         const data = await this.c.request(buildRoomResolve(code), opts.signal);
-        return this.wrap(parseRoom(data), opts, true);
+        return new Room(this.liveDeps(parseRoom(data), opts));
     }
 }
 //# sourceMappingURL=atrium.js.map