@rool-dev/sdk 0.11.3-dev.5dfa2e5 → 0.11.3-dev.7c57c94

package/dist/{channel.js → space-session.js}

@@ -156,34 +156,29 @@ function base64Body(data) {
     return bytes.buffer;
 }
 /**
- * A channel is a space + channelId pair.
+ * Operational handle for a space.
  *
- * All object operations go through a channel. The channelId is fixed
- * at open time and cannot be changed. To use a different channel,
- * open a second one.
- *
- * Objects are addressed by machine path (`/space/.../*.json`).
- * Only schema, metadata, object stats, and the channel's own history are cached
- * locally. Object bodies are fetched on demand. Object/file reactivity is
- * exposed at the space level via WebDAV sync notifications.
+ * Objects are addressed by machine path (`/space/.../*.json`). Conversation handles
+ * control attribution and AI history. Only schema, metadata,
+ * object stats, and conversation history are cached locally. Object bodies are
+ * fetched on demand. Object/file reactivity is exposed at the space level via
+ * WebDAV sync notifications.
  */
-export class RoolChannel extends EventEmitter {
+export class SpaceOperations extends EventEmitter {
     _id;
     _name;
     _role;
     _userId;
-    _channelId;
-    _conversationId;
     _closed = false;
-    graphqlClient;
-    restClient;
-    webdav;
-    onCloseCallback;
-    logger;
-    // Local cache for bounded data (schema, metadata, own channel, object stats)
+    _graphqlClient;
+    _restClient;
+    _webdav;
+    _onCloseCallback;
+    _logger;
+    // Local cache for bounded data (schema, metadata, conversations, object stats)
     _meta;
     _schema;
-    _channel;
+    _conversations;
     _objectStats;
     // Active leaf per conversation (client-side tree cursor)
     _activeLeaves = new Map();
@@ -194,17 +189,15 @@ export class RoolChannel extends EventEmitter {
         this._role = config.role;
         this._userId = config.userId;
         this._emitterLogger = config.logger;
-        this._channelId = config.channelId;
-        this._conversationId = 'default';
-        this.graphqlClient = config.graphqlClient;
-        this.restClient = config.restClient;
-        this.webdav = config.webdav;
-        this.logger = config.logger;
-        this.onCloseCallback = config.onClose;
+        this._graphqlClient = config.graphqlClient;
+        this._restClient = config.restClient;
+        this._webdav = config.webdav;
+        this._logger = config.logger;
+        this._onCloseCallback = config.onClose;
         // Initialize local cache from server data
         this._meta = config.meta;
         this._schema = config.schema;
-        this._channel = config.channel ?? undefined;
+        this._conversations = config.conversations;
         this._objectStats = new Map(Object.entries(config.objectStats));
     }
     /**
@@ -213,11 +206,11 @@ export class RoolChannel extends EventEmitter {
      * @internal
      */
     _handleEvent(event) {
-        this.handleChannelEvent(event);
+        this.applySpaceContentEvent(event);
     }
     /**
      * Apply resync data after reconnection. Called by the client, which
-     * fetches space data once and distributes to all channels.
+     * fetches space data once and applies it.
      * @internal
      */
     _applyResyncData(data) {
@@ -226,8 +219,7 @@ export class RoolChannel extends EventEmitter {
         this._meta = data.meta;
         this._schema = data.schema;
         this._objectStats = new Map(Object.entries(data.objectStats));
-        if (data.channel)
-            this._channel = data.channel;
+        this._conversations = data.conversations;
         this._activeLeaves.clear();
         this.emit('reset', { source: 'system' });
     }
@@ -244,39 +236,12 @@ export class RoolChannel extends EventEmitter {
     get userId() {
         return this._userId;
     }
-    /**
-     * Get the channel's display name, or null if not set.
-     */
-    get channelName() {
-        return this._channel?.name ?? null;
-    }
-    /**
-     * Get the channel ID for this channel.
-     * Fixed at open time — cannot be changed.
-     */
-    get channelId() {
-        return this._channelId;
-    }
-    /**
-     * Get the conversation ID for this channel.
-     * Defaults to 'default' for most apps.
-     */
-    get conversationId() {
-        return this._conversationId;
-    }
     get isReadOnly() {
         return this._role === 'viewer';
     }
-    /**
-     * Get the active branch of the current conversation as a flat array (root → leaf).
-     * Walks from the active leaf up through parentId pointers.
-     */
-    getInteractions() {
-        return this._getInteractionsImpl(this._conversationId);
-    }
     /** @internal */
     _getInteractionsImpl(conversationId) {
-        const interactions = this._channel?.conversations[conversationId]?.interactions;
+        const interactions = this._conversations[conversationId]?.interactions;
         if (!interactions)
             return [];
         // Handle legacy array format
@@ -287,59 +252,35 @@ export class RoolChannel extends EventEmitter {
             return [];
         return walkBranch(interactions, leafId);
     }
-    /**
-     * Get the full interaction tree for a conversation as a record.
-     * For clients that need to render branch navigation UI.
-     */
-    getTree() {
-        return this._getTreeImpl(this._conversationId);
-    }
     /** @internal */
     _getTreeImpl(conversationId) {
-        const interactions = this._channel?.conversations[conversationId]?.interactions;
+        const interactions = this._conversations[conversationId]?.interactions;
         if (!interactions || Array.isArray(interactions))
             return {};
         return interactions;
     }
-    /**
-     * Get the active leaf interaction ID for a conversation.
-     * Returns undefined if the conversation has no interactions.
-     */
-    get activeLeafId() {
-        return this._getActiveLeafImpl(this._conversationId);
-    }
     /** @internal */
     _getActiveLeafImpl(conversationId) {
-        return this._activeLeaves.get(conversationId) ?? findDefaultLeaf(this._channel?.conversations[conversationId]?.interactions);
-    }
-    /**
-     * Set the active leaf for a conversation (switch branches).
-     * Emits a conversationUpdated event so reactive wrappers refresh.
-     */
-    setActiveLeaf(interactionId) {
-        this._setActiveLeafImpl(interactionId, this._conversationId);
+        return this._activeLeaves.get(conversationId) ?? findDefaultLeaf(this._conversations[conversationId]?.interactions);
     }
     /** @internal */
     _setActiveLeafImpl(interactionId, conversationId) {
-        const interactions = this._channel?.conversations[conversationId]?.interactions;
+        const interactions = this._conversations[conversationId]?.interactions;
         if (!interactions || Array.isArray(interactions) || !interactions[interactionId]) {
             throw new Error(`Interaction "${interactionId}" not found in conversation "${conversationId}"`);
         }
         this._activeLeaves.set(conversationId, interactionId);
         this.emit('conversationUpdated', {
             conversationId,
-            channelId: this._channelId,
             source: 'local_user',
         });
     }
     /**
-     * Get all conversations in this channel.
+     * Get all conversations in this space.
      * Returns summary info (no full interaction data) for each conversation.
      */
     getConversations() {
-        if (!this._channel)
-            return [];
-        return Object.entries(this._channel.conversations).map(([id, conv]) => ({
+        return Object.entries(this._conversations).map(([id, conv]) => ({
             id,
             name: conv.name ?? null,
             systemInstruction: conv.systemInstruction ?? null,
@@ -349,74 +290,67 @@ export class RoolChannel extends EventEmitter {
         }));
     }
     /**
-     * Delete a conversation from this channel.
-     * Cannot delete the conversation you are currently using.
+     * Delete a conversation from this space.
      */
     async deleteConversation(conversationId) {
-        if (conversationId === this._conversationId) {
-            throw new Error('Cannot delete the active conversation');
-        }
-        await this.graphqlClient.deleteConversation(this._id, this._channelId, conversationId);
+        await this._graphqlClient.deleteConversation(this._id, conversationId);
         // Optimistic local update — remove from cache and emit event
         // in case the server doesn't send a conversation_updated event for deletes
-        if (this._channel?.conversations[conversationId]) {
-            delete this._channel.conversations[conversationId];
+        if (this._conversations[conversationId]) {
+            delete this._conversations[conversationId];
             this.emit('conversationUpdated', {
                 conversationId,
-                channelId: this._channelId,
                 source: 'local_user',
             });
         }
     }
     /**
-     * Get a handle for a specific conversation within this channel.
+     * Get a handle for a specific conversation.
      */
     conversation(conversationId) {
         return new ConversationHandle(this, conversationId);
     }
     /**
-     * Close this channel and clean up resources.
-     * Stops real-time subscription and unregisters from client.
+     * Close this space session and clean up resources.
      */
     close() {
         this._closed = true;
-        this.onCloseCallback();
+        this._onCloseCallback();
         this.removeAllListeners();
     }
     /**
      * Create a checkpoint of the current space state.
      */
     async checkpoint(label = 'Change') {
-        const result = await this.graphqlClient.checkpoint(this._id, label, this._channelId);
+        const result = await this._graphqlClient.checkpoint(this._id, label);
         return result.checkpointId;
     }
     /** Check if undo is available for this space. */
     async canUndo() {
-        const status = await this.graphqlClient.checkpointStatus(this._id, this._channelId);
+        const status = await this._graphqlClient.checkpointStatus(this._id);
         return status.canUndo;
     }
     /** Check if redo is available for this space. */
     async canRedo() {
-        const status = await this.graphqlClient.checkpointStatus(this._id, this._channelId);
+        const status = await this._graphqlClient.checkpointStatus(this._id);
         return status.canRedo;
     }
     /** Restore the space to the most recent checkpoint. */
     async undo() {
-        const result = await this.graphqlClient.undo(this._id, this._channelId);
+        const result = await this._graphqlClient.undo(this._id);
         return result.success;
     }
     /** Reapply the most recently undone checkpoint. */
     async redo() {
-        const result = await this.graphqlClient.redo(this._id, this._channelId);
+        const result = await this._graphqlClient.redo(this._id);
         return result.success;
     }
     /** Clear the space's checkpoint history. */
     async clearHistory() {
-        await this.graphqlClient.clearCheckpointHistory(this._id, this._channelId);
+        await this._graphqlClient.clearCheckpointHistory(this._id);
     }
     davHeaders(conversationId, interactionId) {
         const headers = new Headers({
-            'X-Rool-Channel-Id': this._channelId,
             'X-Rool-Conversation-Id': conversationId,
         });
         if (interactionId)
@@ -426,7 +360,7 @@ export class RoolChannel extends EventEmitter {
     async readObject(path) {
         const canonical = objectPath(path);
         try {
-            const response = await this.webdav.get(canonical);
+            const response = await this._webdav.get(canonical);
             const body = jsonObject(await response.json(), `Object ${canonical}`);
             return { object: objectFromBody(canonical, body), etag: response.headers.get('ETag') };
         }
@@ -456,7 +390,7 @@ export class RoolChannel extends EventEmitter {
         const result = { objects: [], missing: [] };
         for (let i = 0; i < canonical.length; i += GET_OBJECTS_CHUNK_SIZE) {
             const chunk = canonical.slice(i, i + GET_OBJECTS_CHUNK_SIZE);
-            const partial = await this.restClient.getObjects(this._id, chunk);
+            const partial = await this._restClient.getObjects(this._id, chunk);
             result.objects.push(...partial.objects);
             result.missing.push(...partial.missing);
         }
@@ -466,17 +400,13 @@ export class RoolChannel extends EventEmitter {
     stat(path) {
         return this._objectStats.get(objectPath(path));
     }
-    /** Create or replace an object JSON file at an exact machine path. */
-    async putObject(path, body) {
-        return this._putObjectImpl(path, body, this._conversationId);
-    }
     /** @internal */
     async _putObjectImpl(path, body, conversationId) {
         const canonical = objectPath(path);
         const optimistic = objectFromBody(canonical, body);
         try {
             const interactionId = generateEntityId();
-            await this.webdav.put(canonical, JSON.stringify(body), {
+            await this._webdav.put(canonical, JSON.stringify(body), {
                 contentType: 'application/json',
                 headers: this.davHeaders(conversationId, interactionId),
             });
@@ -484,15 +414,11 @@ export class RoolChannel extends EventEmitter {
             return { object: fresh, message: `Put ${canonical}` };
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to put object:', error);
+            this._logger.error('[RoolSpace] Failed to put object:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
     }
-    /** Patch an existing object. Null or undefined deletes a field. */
-    async patchObject(path, options) {
-        return this._patchObjectImpl(path, options, this._conversationId);
-    }
     /** @internal */
     async _patchObjectImpl(path, options, conversationId) {
         const canonical = objectPath(path);
@@ -504,7 +430,7 @@ export class RoolChannel extends EventEmitter {
         const optimistic = objectFromBody(canonical, body);
         try {
             const interactionId = generateEntityId();
-            await this.webdav.put(canonical, JSON.stringify(body), {
+            await this._webdav.put(canonical, JSON.stringify(body), {
                 contentType: 'application/json',
                 ifMatch: current.etag ?? undefined,
                 headers: this.davHeaders(conversationId, interactionId),
@@ -513,15 +439,11 @@ export class RoolChannel extends EventEmitter {
             return { object: fresh, message: `Patched ${canonical}` };
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to patch object:', error);
+            this._logger.error('[RoolSpace] Failed to patch object:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
     }
-    /** Move an object JSON file to a new machine path, optionally replacing its body. */
-    async moveObject(from, to, options) {
-        return this._moveObjectImpl(from, to, options, this._conversationId);
-    }
     /** @internal */
     async _moveObjectImpl(from, to, options, conversationId) {
         const fromPath = objectPath(from);
@@ -529,11 +451,11 @@ export class RoolChannel extends EventEmitter {
         const optimistic = objectFromBody(toPath, options?.body ?? {});
         try {
             const interactionId = generateEntityId();
-            await this.webdav.move(fromPath, toPath, {
+            await this._webdav.move(fromPath, toPath, {
                 headers: this.davHeaders(conversationId, interactionId),
             });
             if (options?.body) {
-                await this.webdav.put(toPath, JSON.stringify(options.body), {
+                await this._webdav.put(toPath, JSON.stringify(options.body), {
                     contentType: 'application/json',
                     headers: this.davHeaders(conversationId, interactionId),
                 });
@@ -543,19 +465,11 @@ export class RoolChannel extends EventEmitter {
             return { object: fresh, message: `Moved ${fromPath} to ${toPath}` };
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to move object:', error);
+            this._logger.error('[RoolSpace] Failed to move object:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
     }
-    /** Delete object JSON files by machine path. */
-    async deleteObjects(paths) {
-        return this._deleteObjectsImpl(paths, this._conversationId);
-    }
-    /** @deprecated Use deleteObjects instead. */
-    async deletePaths(paths) {
-        return this.deleteObjects(paths);
-    }
     /** @internal */
     async _deleteObjectsImpl(paths, conversationId) {
         if (paths.length === 0)
@@ -564,14 +478,14 @@ export class RoolChannel extends EventEmitter {
         try {
             const interactionId = generateEntityId();
             for (const path of canonical) {
-                await this.webdav.delete(path, {
+                await this._webdav.delete(path, {
                     headers: this.davHeaders(conversationId, interactionId),
                 });
                 this._objectStats.delete(path);
             }
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to delete paths:', error);
+            this._logger.error('[RoolSpace] Failed to delete paths:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
@@ -580,10 +494,6 @@ export class RoolChannel extends EventEmitter {
     getSchema() {
         return this._schema;
     }
-    /** Create a new collection schema. */
-    async createCollection(name, fields, options) {
-        return this._createCollectionImpl(name, fields, options, this._conversationId);
-    }
     /** @internal */
     async _createCollectionImpl(name, fields, options, conversationId) {
         if (this._schema[name]) {
@@ -593,8 +503,8 @@ export class RoolChannel extends EventEmitter {
         const optimisticDef = collectionDef(fields, options);
         this._schema[name] = optimisticDef;
         try {
-            await this.webdav.mkcol(collectionPath(name), { headers: this.davHeaders(conversationId, generateEntityId()) });
-            await this.webdav.put(schemaPath(name), JSON.stringify(optimisticDef), {
+            await this._webdav.mkcol(collectionPath(name), { headers: this.davHeaders(conversationId, generateEntityId()) });
+            await this._webdav.put(schemaPath(name), JSON.stringify(optimisticDef), {
                 contentType: 'application/json',
                 headers: this.davHeaders(conversationId, generateEntityId()),
             });
@@ -602,15 +512,11 @@ export class RoolChannel extends EventEmitter {
             return optimisticDef;
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to create collection:', error);
+            this._logger.error('[RoolSpace] Failed to create collection:', error);
             delete this._schema[name];
             throw error;
         }
     }
-    /** Alter an existing collection schema, replacing its field definitions. */
-    async alterCollection(name, fields, options) {
-        return this._alterCollectionImpl(name, fields, options, this._conversationId);
-    }
     /** @internal */
     async _alterCollectionImpl(name, fields, options, conversationId) {
         if (!this._schema[name]) {
@@ -620,7 +526,7 @@ export class RoolChannel extends EventEmitter {
         this._schema[name] = collectionDef(fields, options);
         try {
             const updated = this._schema[name];
-            await this.webdav.put(schemaPath(name), JSON.stringify(updated), {
+            await this._webdav.put(schemaPath(name), JSON.stringify(updated), {
                 contentType: 'application/json',
                 headers: this.davHeaders(conversationId, generateEntityId()),
             });
@@ -628,15 +534,11 @@ export class RoolChannel extends EventEmitter {
             return updated;
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to alter collection:', error);
+            this._logger.error('[RoolSpace] Failed to alter collection:', error);
             this._schema[name] = previous;
             throw error;
         }
     }
-    /** Drop a collection schema. */
-    async dropCollection(name) {
-        return this._dropCollectionImpl(name, this._conversationId);
-    }
     /** @internal */
     async _dropCollectionImpl(name, conversationId) {
         if (!this._schema[name]) {
@@ -645,33 +547,23 @@ export class RoolChannel extends EventEmitter {
         const previous = this._schema[name];
         delete this._schema[name];
         try {
-            await this.webdav.delete(collectionPath(name), { collection: true, headers: this.davHeaders(conversationId, generateEntityId()) });
+            await this._webdav.delete(collectionPath(name), { collection: true, headers: this.davHeaders(conversationId, generateEntityId()) });
             this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to drop collection:', error);
+            this._logger.error('[RoolSpace] Failed to drop collection:', error);
             this._schema[name] = previous;
             throw error;
         }
     }
-    /**
-     * Get the system instruction for the current conversation.
-     */
-    getSystemInstruction() {
-        return this._getSystemInstructionImpl(this._conversationId);
-    }
     /** @internal */
     _getSystemInstructionImpl(conversationId) {
-        return this._channel?.conversations[conversationId]?.systemInstruction;
-    }
-    /** Set the system instruction for the current conversation. */
-    async setSystemInstruction(instruction) {
-        return this._setSystemInstructionImpl(instruction, this._conversationId);
+        return this._conversations[conversationId]?.systemInstruction;
     }
     /** @internal */
     async _setSystemInstructionImpl(instruction, conversationId) {
         this._ensureConversationImpl(conversationId);
-        const conv = this._channel.conversations[conversationId];
+        const conv = this._conversations[conversationId];
         const previousInstruction = conv.systemInstruction;
         if (instruction === null) {
             delete conv.systemInstruction;
@@ -681,20 +573,13 @@ export class RoolChannel extends EventEmitter {
         }
         this.emit('conversationUpdated', {
             conversationId,
-            channelId: this._channelId,
             source: 'local_user',
         });
-        if (conversationId === this._conversationId) {
-            this.emit('channelUpdated', {
-                channelId: this._channelId,
-                source: 'local_user',
-            });
-        }
         try {
-            await this.graphqlClient.updateConversation(this._id, this._channelId, conversationId, { systemInstruction: instruction });
+            await this._graphqlClient.updateConversation(this._id, conversationId, { systemInstruction: instruction });
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to set system instruction:', error);
+            this._logger.error('[RoolSpace] Failed to set system instruction:', error);
             if (previousInstruction === undefined) {
                 delete conv.systemInstruction;
             }
@@ -704,65 +589,43 @@ export class RoolChannel extends EventEmitter {
             throw error;
         }
     }
-    /** Rename the current conversation. */
-    async renameConversation(name) {
-        return this._renameConversationImpl(name, this._conversationId);
-    }
     /** @internal */
     async _renameConversationImpl(name, conversationId) {
         this._ensureConversationImpl(conversationId);
-        const conv = this._channel.conversations[conversationId];
+        const conv = this._conversations[conversationId];
         const previousName = conv.name;
         conv.name = name;
         this.emit('conversationUpdated', {
             conversationId,
-            channelId: this._channelId,
             source: 'local_user',
         });
-        if (conversationId === this._conversationId) {
-            this.emit('channelUpdated', {
-                channelId: this._channelId,
-                source: 'local_user',
-            });
-        }
         try {
-            await this.graphqlClient.updateConversation(this._id, this._channelId, conversationId, { name });
+            await this._graphqlClient.updateConversation(this._id, conversationId, { name });
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to rename conversation:', error);
+            this._logger.error('[RoolSpace] Failed to rename conversation:', error);
             conv.name = previousName;
             throw error;
         }
     }
     /** @internal */
     _ensureConversationImpl(conversationId) {
-        if (!this._channel) {
-            this._channel = {
-                createdAt: Date.now(),
-                createdBy: this._userId,
-                conversations: {},
-            };
-        }
-        if (!this._channel.conversations[conversationId]) {
-            this._channel.conversations[conversationId] = {
+        if (!this._conversations[conversationId]) {
+            this._conversations[conversationId] = {
                 createdAt: Date.now(),
                 createdBy: this._userId,
                 interactions: {},
             };
         }
     }
-    /** Set a space-level metadata value. */
-    setMetadata(key, value) {
-        this._setMetadataImpl(key, value, this._conversationId);
-    }
     /** @internal */
     _setMetadataImpl(key, value, conversationId) {
         this._meta[key] = value;
         this.emit('metadataUpdated', { metadata: this._meta, source: 'local_user' });
         // Fire-and-forget server call
-        this.graphqlClient.setSpaceMeta(this._id, this._meta, this._channelId, conversationId)
+        this._graphqlClient.setSpaceMeta(this._id, this._meta, conversationId)
             .catch((error) => {
-            this.logger.error('[RoolChannel] Failed to set meta:', error);
+            this._logger.error('[RoolSpace] Failed to set meta:', error);
         });
     }
     /** Get a space-level metadata value. */
@@ -773,13 +636,6 @@ export class RoolChannel extends EventEmitter {
     getAllMetadata() {
         return this._meta;
     }
-    /**
-     * Send a prompt to the AI agent for space manipulation.
-     * @returns The message from the AI and the list of objects that were created or modified.
-     */
-    async prompt(prompt, options) {
-        return this._promptImpl(prompt, options, this._conversationId);
-    }
     /** @internal */
     async _promptImpl(prompt, options, conversationId) {
         const { attachments, parentInteractionId: explicitParent, signal, ...rest } = options ?? {};
@@ -811,7 +667,7 @@ export class RoolChannel extends EventEmitter {
         }
         let result;
         try {
-            result = await this.graphqlClient.prompt(this._id, prompt, this._channelId, conversationId, {
+            result = await this._graphqlClient.prompt(this._id, prompt, conversationId, {
                 ...rest,
                 attachmentRefs,
                 interactionId,
@@ -833,32 +689,21 @@ export class RoolChannel extends EventEmitter {
             objects,
         };
     }
-    /**
-     * Stop the in-flight interaction on the default conversation, if any.
-     *
-     * No-op returning `false` when the active leaf is already finished or the
-     * conversation has no interactions. Stopping is best-effort: the server
-     * halts the agent loop and closes the stream, but an LLM turn already in
-     * flight keeps generating server-side and is billed.
-     */
-    async stop() {
-        return this._stopImpl(this._conversationId);
-    }
     /**
      * Request that the server stop a specific in-flight interaction by ID.
      *
      * Returns whether the server stopped an interaction (`false` if it had
-     * already finished). Stopping is best-effort — see {@link stop}.
+     * already finished). Stopping is best-effort — see {@link ConversationHandle.stop}.
      */
     async stopInteraction(interactionId) {
-        return this.graphqlClient.stopInteraction(this._id, interactionId);
+        return this._graphqlClient.stopInteraction(this._id, interactionId);
     }
     /** @internal */
     async _stopImpl(conversationId) {
         const leafId = this._getActiveLeafImpl(conversationId);
         if (!leafId)
             return false;
-        const interactions = this._channel?.conversations[conversationId]?.interactions;
+        const interactions = this._conversations[conversationId]?.interactions;
         const interaction = interactions && !Array.isArray(interactions) ? interactions[leafId] : undefined;
         // Skip the round trip when we already know the interaction has settled.
         if (interaction && (interaction.status === 'done' || interaction.status === 'error')) {
@@ -866,29 +711,11 @@ export class RoolChannel extends EventEmitter {
         }
         return this.stopInteraction(leafId);
     }
-    /** Rename this channel. */
-    async rename(newName) {
-        const previousName = this._channel?.name;
-        if (this._channel) {
-            this._channel.name = newName;
-        }
-        this.emit('channelUpdated', { channelId: this._channelId, source: 'local_user' });
-        try {
-            await this.graphqlClient.renameChannel(this._id, this._channelId, newName);
-        }
-        catch (error) {
-            this.logger.error('[RoolChannel] Failed to rename channel:', error);
-            if (this._channel) {
-                this._channel.name = previousName;
-            }
-            throw error;
-        }
-    }
     /**
      * Fetch an external URL via the server proxy, bypassing CORS restrictions.
      */
     async fetch(url, init) {
-        return this.restClient.proxyFetch(this._id, url, init);
+        return this._restClient.proxyFetch(this._id, url, init);
     }
     async uploadAttachment(file, conversationId) {
         await this.ensureCollection('/rool-drive/attachments');
@@ -896,70 +723,32 @@ export class RoolChannel extends EventEmitter {
         await this.ensureCollection(directory);
         const attachment = attachmentBody(file);
         const path = `${directory}/${attachment.filename}`;
-        await this.webdav.put(path, attachment.body, { contentType: attachment.contentType });
+        await this._webdav.put(path, attachment.body, { contentType: attachment.contentType });
         return path;
     }
     async ensureCollection(path) {
-        const response = await this.webdav.request('MKCOL', path, { collection: true });
+        const response = await this._webdav.request('MKCOL', path, { collection: true });
         if (response.status === 201 || response.status === 405)
             return;
         throw new Error(`Failed to create collection ${path}: ${response.status} ${await response.text()}`);
     }
     /**
-     * Handle a channel event from the subscription.
+     * Handle a space event from the subscription.
      * @internal
      */
-    handleChannelEvent(event) {
+    applySpaceContentEvent(event) {
         if (this._closed)
             return;
         const changeSource = event.source === 'agent' ? 'remote_agent' : 'remote_user';
         switch (event.type) {
-            case 'connected':
-                // Resync is handled by the client via _applyResyncData.
-                break;
-            case 'schema_updated':
-                if (event.schema) {
-                    this._schema = event.schema;
-                    this.emit('schemaUpdated', { schema: this._schema, source: changeSource });
-                }
-                break;
-            case 'metadata_updated':
-                if (event.metadata) {
-                    this._meta = event.metadata;
-                    this.emit('metadataUpdated', { metadata: this._meta, source: changeSource });
-                }
-                break;
-            case 'channel_updated':
-                if (event.channelId === this._channelId && event.channel) {
-                    const changed = JSON.stringify(this._channel) !== JSON.stringify(event.channel);
-                    this._channel = event.channel;
-                    if (changed) {
-                        this.emit('channelUpdated', { channelId: event.channelId, source: changeSource });
-                    }
-                }
-                break;
-            case 'channel_deleted':
-                if (event.channelId === this._channelId) {
-                    this._channel = undefined;
-                    this._activeLeaves.clear();
-                    this.emit('reset', { source: changeSource });
-                }
-                break;
             case 'conversation_updated':
-                if (event.channelId === this._channelId && event.conversationId) {
-                    if (!this._channel) {
-                        this._channel = {
-                            createdAt: Date.now(),
-                            createdBy: this._userId,
-                            conversations: {},
-                        };
-                    }
-                    const prev = this._channel.conversations[event.conversationId];
+                if (event.conversationId) {
+                    const prev = this._conversations[event.conversationId];
                     if (event.conversation) {
-                        this._channel.conversations[event.conversationId] = event.conversation;
+                        this._conversations[event.conversationId] = event.conversation;
                     }
                     else {
-                        delete this._channel.conversations[event.conversationId];
+                        delete this._conversations[event.conversationId];
                     }
                     if (JSON.stringify(prev) === JSON.stringify(event.conversation))
                         break;
@@ -976,77 +765,74 @@ export class RoolChannel extends EventEmitter {
                     }
                     this.emit('conversationUpdated', {
                         conversationId: event.conversationId,
-                        channelId: event.channelId,
                         source: changeSource,
                     });
-                    if (event.conversationId === this._conversationId) {
-                        this.emit('channelUpdated', { channelId: event.channelId, source: changeSource });
-                    }
                 }
                 break;
-            case 'space_changed':
-                // Resync is handled by the client via _applyResyncData.
-                break;
         }
     }
 }
 /**
- * A lightweight handle for a specific conversation within a channel.
+ * A lightweight handle for a specific conversation.
  */
 export class ConversationHandle {
     /** @internal */
-    _channel;
+    _space;
     _conversationId;
     /** @internal */
-    constructor(channel, conversationId) {
-        this._channel = channel;
+    constructor(space, conversationId) {
+        this._space = space;
         this._conversationId = conversationId;
     }
     /** The conversation ID this handle is scoped to. */
     get conversationId() { return this._conversationId; }
     /** Get the active branch of this conversation as a flat array (root → leaf). */
     getInteractions() {
-        return this._channel._getInteractionsImpl(this._conversationId);
+        return this._space._getInteractionsImpl(this._conversationId);
     }
     /** Get the full interaction tree as a record. */
     getTree() {
-        return this._channel._getTreeImpl(this._conversationId);
+        return this._space._getTreeImpl(this._conversationId);
     }
     /** Get the active leaf interaction ID, or undefined if empty. */
     get activeLeafId() {
-        return this._channel._getActiveLeafImpl(this._conversationId);
+        return this._space._getActiveLeafImpl(this._conversationId);
     }
     /** Switch to a different branch by setting the active leaf. */
     setActiveLeaf(interactionId) {
-        this._channel._setActiveLeafImpl(interactionId, this._conversationId);
+        this._space._setActiveLeafImpl(interactionId, this._conversationId);
     }
     /** Get the system instruction for this conversation. */
     getSystemInstruction() {
-        return this._channel._getSystemInstructionImpl(this._conversationId);
+        return this._space._getSystemInstructionImpl(this._conversationId);
     }
     /** Set the system instruction for this conversation. Pass null to clear. */
     async setSystemInstruction(instruction) {
-        return this._channel._setSystemInstructionImpl(instruction, this._conversationId);
+        return this._space._setSystemInstructionImpl(instruction, this._conversationId);
     }
     /** Rename this conversation. */
     async rename(name) {
-        return this._channel._renameConversationImpl(name, this._conversationId);
+        return this._space._renameConversationImpl(name, this._conversationId);
+    }
+    /** Delete this conversation. */
+    async delete() {
+        return this._space.deleteConversation(this._conversationId);
     }
     /** Create or replace an object JSON file. */
     async putObject(path, body) {
-        return this._channel._putObjectImpl(path, body, this._conversationId);
+        return this._space._putObjectImpl(path, body, this._conversationId);
     }
     /** Patch an existing object JSON file. */
     async patchObject(path, options) {
-        return this._channel._patchObjectImpl(path, options, this._conversationId);
+        return this._space._patchObjectImpl(path, options, this._conversationId);
     }
     /** Move (rename/relocate) an object. */
     async moveObject(from, to, options) {
-        return this._channel._moveObjectImpl(from, to, options, this._conversationId);
+        return this._space._moveObjectImpl(from, to, options, this._conversationId);
     }
     /** Delete object JSON files by path. */
     async deleteObjects(paths) {
-        return this._channel._deleteObjectsImpl(paths, this._conversationId);
+        return this._space._deleteObjectsImpl(paths, this._conversationId);
     }
     /** @deprecated Use deleteObjects instead. */
     async deletePaths(paths) {
@@ -1054,30 +840,30 @@ export class ConversationHandle {
     }
     /** Send a prompt to the AI agent, scoped to this conversation's history. */
     async prompt(text, options) {
-        return this._channel._promptImpl(text, options, this._conversationId);
+        return this._space._promptImpl(text, options, this._conversationId);
     }
     /**
      * Stop this conversation's in-flight interaction, if any. No-op returning
      * `false` when nothing is running. Stopping is best-effort — see
-     * {@link RoolChannel.stop}.
+     * {@link RoolSpace.stopInteraction}.
      */
     async stop() {
-        return this._channel._stopImpl(this._conversationId);
+        return this._space._stopImpl(this._conversationId);
     }
     /** Create a new collection schema. */
     async createCollection(name, fields, options) {
-        return this._channel._createCollectionImpl(name, fields, options, this._conversationId);
+        return this._space._createCollectionImpl(name, fields, options, this._conversationId);
     }
     /** Alter an existing collection schema. */
     async alterCollection(name, fields, options) {
-        return this._channel._alterCollectionImpl(name, fields, options, this._conversationId);
+        return this._space._alterCollectionImpl(name, fields, options, this._conversationId);
     }
     /** Drop a collection schema. */
     async dropCollection(name) {
-        return this._channel._dropCollectionImpl(name, this._conversationId);
+        return this._space._dropCollectionImpl(name, this._conversationId);
     }
     setMetadata(key, value) {
-        return this._channel._setMetadataImpl(key, value, this._conversationId);
+        return this._space._setMetadataImpl(key, value, this._conversationId);
     }
 }
-//# sourceMappingURL=channel.js.map
+//# sourceMappingURL=space-session.js.map