@rool-dev/svelte 0.8.1 → 0.8.2-dev.d82ea25

package/README.md

@@ -2,9 +2,7 @@
 
 Svelte 5 bindings for Rool Spaces. Adds reactive state to the SDK using `$state` runes.
 
-> **Building a new Rool extension?** Start with [`@rool-dev/extension`](/extension/) — it includes a reactive channel and handles hosting for you. This package is for integrating Rool into an existing Svelte application that manages its own auth, routing, and build setup.
-
-**Requires Svelte 5.** For core concepts (objects, references, AI placeholders, undo/redo), see the [SDK documentation](../sdk/README.md).
+**Requires Svelte 5.** For core concepts (objects, references, AI, WebDAV files, undo/redo), see the [SDK documentation](../sdk/README.md).
 
 ## Installation
 
@@ -15,16 +13,18 @@ npm install @rool-dev/svelte
 ## Quick Start
 
 ```svelte
-<script>
-  import { createRool } from '@rool-dev/svelte';
+<script lang="ts">
+  import { createRool, type ReactiveChannel } from '@rool-dev/svelte';
 
   const rool = createRool();
-  rool.init();
+  void rool.init();
 
-  let channel = $state(null);
+  let channel = $state<ReactiveChannel | null>(null);
 </script>
 
-{#if !rool.authenticated}
+{#if rool.authenticated === null}
+  <p>Checking session...</p>
+{:else if !rool.authenticated}
   <button onclick={() => rool.login('My App')}>Login</button>
 {:else}
   <h1>My Spaces</h1>
@@ -50,14 +50,16 @@ The Svelte wrapper adds reactive state on top of the SDK:
 | Reactive Property | Description |
 |-------------------|-------------|
 | `rool.authenticated` | Auth state (`null` = checking, `true`/`false` = known) |
+| `rool.currentUser` | Current user profile after authentication |
 | `rool.spaces` | List of available spaces |
 | `rool.spacesLoading` | Whether spaces are loading |
 | `rool.spacesError` | Error from loading spaces |
-| `rool.connectionState` | SSE connection state |
+| `rool.connectionState` | Client SSE connection state |
 | `rool.userStorage` | User storage (cross-device preferences) |
-| `channel.interactions` | Channel interactions (auto-updates) |
-| `channel.objectIds` | All object IDs in the space (auto-updates on create/delete) |
-| `channel.collections` | Collection names from the schema (auto-updates) |
+| `space.fileTree` | Canonical reactive WebDAV tree for `/`, including `/space` objects and `/rool-drive` user files |
+| `channel.interactions` | Current conversation interactions |
+| `channel.objectPaths` | Object paths derived from `space.fileTree` |
+| `channel.collections` | Collection directories derived from `space.fileTree` |
 | `channel.conversations` | Conversations in this channel (auto-updates on create/delete/rename) |
 | `thread.interactions` | Interactions for a specific conversation (auto-updates) |
 | `watch.objects` | Objects matching a filter (auto-updates) |
@@ -65,6 +67,22 @@ The Svelte wrapper adds reactive state on top of the SDK:
 
 Everything else passes through to the SDK directly. See the [SDK documentation](../sdk/README.md) for full API details.
 
+### Reactive File Tree
+
+Every `ReactiveSpace` owns a canonical reactive WebDAV tree. It is kept current with server `filesChanged`/`filesReset` events and WebDAV `sync-collection`, so it covers both object files and user files without polling.
+
+```ts
+const space = await rool.openSpace(spaceId);
+
+space.fileTree.nodes;              // ReactiveFileNode[]
+space.fileTree.byPath['/space'];   // lookup by machine/WebDAV path
+space.fileTree.childrenOf('/');    // /space and /rool-drive
+space.fileTree.childrenOf('/rool-drive');
+space.fileTree.objectPaths();      // object paths from /space/**/*.json
+```
+
+Use this tree when UI needs to react to both files and objects. Object helpers like `channel.object()`, `channel.watch()`, `channel.objectPaths`, and `channel.collections` are backed by this tree.
+
 ## API
 
 ### Lifecycle
@@ -72,7 +90,7 @@ Everything else passes through to the SDK directly. See the [SDK documentation](
 ```typescript
 const rool = createRool();
 
-rool.init();              // Process auth callbacks (call on app startup)
+void rool.init();         // Process auth callbacks (call on app startup)
 rool.login('My App');     // Redirect to login page
 rool.signup('My App');    // Redirect to signup page
 rool.verify(token);       // Sign in from an email verification link (used by the official Rool app)
@@ -91,6 +109,7 @@ rool.destroy();           // Clean up all resources
   // rool.spacesError      → Error | null
   // rool.connectionState  → 'connected' | 'disconnected' | 'reconnecting'
   // rool.userStorage      → Record<string, unknown>
+  // rool.currentUser      → CurrentUser | null
 </script>
 
 {#if rool.spacesLoading}
@@ -109,9 +128,10 @@ rool.destroy();           // Clean up all resources
 Reactive cross-device storage for user preferences. Synced from server on `init()`, then kept up-to-date via SSE.
 
 ```svelte
-<script>
+<script lang="ts">
+  import { createRool } from '@rool-dev/svelte';
   const rool = createRool();
-  rool.init();
+  void rool.init();
 </script>
 
 <!-- Reactive binding to storage values -->
@@ -122,9 +142,7 @@ Reactive cross-device storage for user preferences. Synced from server on `init(
 {/if}
 
 <!-- Theme toggle -->
-<button onclick={() => rool.setUserStorage('theme',
-  rool.userStorage.theme === 'dark' ? 'light' : 'dark'
-)}>
+<button onclick={() => rool.setUserStorage('theme', rool.userStorage.theme === 'dark' ? 'light' : 'dark')}>
   Toggle theme
 </button>
 ```
@@ -161,47 +179,55 @@ space.close();
 
 ### ReactiveChannel
 
-`space.openChannel()` returns a `ReactiveChannel` — the SDK's `RoolChannel` with reactive `interactions` and `objectIds`:
+`space.openChannel()` returns a `ReactiveChannel` — the SDK's `RoolChannel` with reactive `interactions`, `objectPaths`, `collections`, `conversations`, and file-tree-backed object helpers:
 
 ```svelte
-<script>
-  let space = $state(null);
-  let channel = $state(null);
+<script lang="ts">
+  import { createRool, type ReactiveChannel, type ReactiveSpace } from '@rool-dev/svelte';
+
+  const rool = createRool();
+  void rool.init();
+
+  let space = $state<ReactiveSpace | null>(null);
+  let channel = $state<ReactiveChannel | null>(null);
 
-  async function open(spaceId) {
+  async function open(spaceId: string) {
     space = await rool.openSpace(spaceId);
     channel = await space.openChannel('main');
   }
 </script>
 
 {#if channel}
-  <!-- Reactive: updates as AI makes tool calls -->
+  <!-- Reactive: updates when the current conversation changes -->
   {#each channel.interactions as interaction}
     <div>
-      <strong>{interaction.operation}</strong>: {interaction.output}
+      <strong>{interaction.operation}</strong>: {interaction.output ?? ''}
     </div>
   {/each}
 
   <!-- All SDK methods work directly -->
-  <button onclick={() => channel.prompt('Hello')}>Send</button>
+  <button onclick={() => void channel.prompt('Hello')}>Send</button>
 {/if}
 ```
 
 ### Reactive Object
 
-Track a single object by ID with auto-updates:
+Track a single object by machine path with auto-updates:
 
 ```svelte
-<script>
-  let channel = $state(null);
-  let item = $state(null);
+<script lang="ts">
+  import { createRool, type ReactiveChannel, type ReactiveObject } from '@rool-dev/svelte';
+
+  const rool = createRool();
+  void rool.init();
 
-  let space = $state(null);
+  let channel = $state<ReactiveChannel | null>(null);
+  let item = $state<ReactiveObject | null>(null);
 
-  async function open(spaceId, objectId) {
-    space = await rool.openSpace(spaceId);
+  async function open(spaceId: string, path: string) {
+    const space = await rool.openSpace(spaceId);
     channel = await space.openChannel('main');
-    item = channel.object(objectId);
+    item = channel.object(path);  // e.g. '/space/article/welcome.json'
   }
 </script>
 
@@ -209,7 +235,7 @@ Track a single object by ID with auto-updates:
   {#if item.loading}
     <p>Loading...</p>
   {:else if item.data}
-    <div>{item.data.title}</div>
+    <div>{String(item.data.body.title ?? '')}</div>
   {:else}
     <p>Object not found</p>
   {/if}
@@ -233,16 +259,19 @@ item.close()   // Stop listening for updates
 Create auto-updating watches of objects filtered by field values:
 
 ```svelte
-<script>
-  let channel = $state(null);
-  let articles = $state(null);
+<script lang="ts">
+  import { createRool, type ReactiveChannel, type ReactiveSpace, type ReactiveWatch } from '@rool-dev/svelte';
 
-  let space = $state(null);
+  const rool = createRool();
+  void rool.init();
 
-  async function open(spaceId) {
+  let space = $state<ReactiveSpace | null>(null);
+  let channel = $state<ReactiveChannel | null>(null);
+  let articles = $state<ReactiveWatch | null>(null);
+  async function open(spaceId: string) {
     space = await rool.openSpace(spaceId);
     channel = await space.openChannel('main');
-    // Create a reactive watch of all objects where type === 'article'
+    // Create a reactive watch of all objects in the 'article' collection
     articles = channel.watch({ collection: 'article' });
   }
 </script>
@@ -252,18 +281,18 @@ Create auto-updating watches of objects filtered by field values:
     <p>Loading...</p>
   {:else}
     {#each articles.objects as article}
-      <div>{article.title}</div>
+      <div>{String(article.body.title ?? '')}</div>
     {/each}
   {/if}
 {/if}
 ```
 
-Watches automatically re-fetch when objects matching the filter are created, updated, or deleted. Since the SDK caches objects locally, re-fetches are typically instant (no network round-trip).
+Watches automatically re-fetch when matching object files change in `space.fileTree`.
 
 **Lifecycle:** Watches are tied to their channel. Closing the channel stops all updates — existing watches will retain their last data but no longer refresh. Calling `channel.watch()` after `close()` throws.
 
 ```typescript
-// Watch options (same as findObjects, but no AI prompt)
+// Watch options
 const articles = channel.watch({
   collection: 'article',
   where: { status: 'published' },
@@ -282,36 +311,51 @@ articles.close()   // Stop listening for updates
 
 ### Reactive Channel List
 
-`space.channels` is a reactive `ChannelInfo[]` that auto-updates as channels are created, renamed, or deleted.
+`space.channels` is a reactive `ChannelInfo[]` on an opened `ReactiveSpace`. If you only need a live channel list without managing a `ReactiveSpace`, use `rool.channels(spaceId)` and call `close()` when done.
 
 ```svelte
-<script>
-  let space = $state(null);
+<script lang="ts">
+  import { createRool, type ReactiveSpace } from '@rool-dev/svelte';
 
-  async function open(spaceId) {
+  const rool = createRool();
+  void rool.init();
+
+  let space = $state<ReactiveSpace | null>(null);
+  async function open(spaceId: string) {
     space = await rool.openSpace(spaceId);
   }
 </script>
 
 {#if space}
   {#each space.channels as ch}
-    <button onclick={() => space.openChannel(ch.id)}>{ch.name ?? ch.id}</button>
+    <button onclick={() => void space.openChannel(ch.id)}>{ch.name ?? ch.id}</button>
   {/each}
 {/if}
 ```
 
+```typescript
+const channels = rool.channels(spaceId);
+channels.list;       // ChannelInfo[]
+channels.loading;    // boolean
+await channels.refresh();
+channels.close();
+```
+
 ### Reactive Conversation Handle
 
 For apps with multiple independent interaction threads (e.g., chat with threads), use `channel.conversation()` to get a handle with reactive interactions:
 
 ```svelte
-<script>
-  let channel = $state(null);
-  let thread = $state(null);
+<script lang="ts">
+  import { createRool, type ReactiveChannel, type ReactiveConversationHandle, type ReactiveSpace } from '@rool-dev/svelte';
 
-  let space = $state(null);
+  const rool = createRool();
+  void rool.init();
 
-  async function openThread(spaceId, threadId) {
+  let space = $state<ReactiveSpace | null>(null);
+  let channel = $state<ReactiveChannel | null>(null);
+  let thread = $state<ReactiveConversationHandle | null>(null);
+  async function openThread(spaceId: string, threadId: string) {
     space = await rool.openSpace(spaceId);
     channel = await space.openChannel('main');
     thread = channel.conversation(threadId);
@@ -323,17 +367,19 @@ For apps with multiple independent interaction threads (e.g., chat with threads)
     <div>{interaction.output}</div>
   {/each}
 
-  <button onclick={() => thread.prompt('Hello')}>Send</button>
+  <button onclick={() => void thread.prompt('Hello')}>Send</button>
 {/if}
 ```
 
 ```typescript
 // Reactive state
-thread.interactions   // $state<Interaction[]> — auto-updates via SSE
+thread.interactions   // $state<Interaction[]> — updates from space/channel events
 
-// All conversation-scoped methods
+// Conversation-scoped methods
 await thread.prompt('Hello')
-await thread.createObject({ data: { type: 'note', text: 'Note' } })
+await thread.stop()   // Stop this thread's in-flight interaction (false if none)
+await thread.putObject('/space/note/welcome.json', { text: 'Note' })
+await thread.patchObject('/space/note/welcome.json', { data: { text: 'Updated' } })
 await thread.setSystemInstruction('Respond in haiku')
 await thread.rename('Research Thread')
 thread.getInteractions()      // Manual read
@@ -343,7 +389,7 @@ thread.getSystemInstruction()
 thread.close()   // Stop listening for updates
 ```
 
-Conversations are auto-created on first interaction. All conversations share one SSE connection per channel.
+Conversations are auto-created when you first write history or settings. Real-time events are owned by the space subscription; conversation handles subscribe to channel events locally.
 
 ### Channel Management
 
@@ -369,15 +415,18 @@ channel.name
 channel.role
 channel.channelId
 
-// Object operations
-await channel.getObject(id)
-await channel.createObject({ data: { type: 'note', text: 'Hello' } })
-await channel.updateObject(id, { data: { text: 'Updated' } })
-await channel.deleteObjects([id])
-await channel.findObjects({ collection: 'note' })
+// Object operations — addressed by exact machine paths
+const path = '/space/note/welcome.json';
+await channel.getObject(path)
+await channel.putObject(path, { text: 'Hello' })
+await channel.patchObject(path, { data: { text: 'Updated' } })
+await channel.moveObject(path, '/space/note/renamed.json')
+await channel.deleteObjects(['/space/note/renamed.json'])
 
 // AI
 await channel.prompt('Summarize everything')
+await channel.stop()                       // Stop the in-flight interaction (false if none)
+await channel.stopInteraction(channel.activeLeafId!)  // Stop a specific interaction by ID
 
 // Schema
 channel.getSchema()
@@ -385,7 +434,7 @@ await channel.createCollection('article', [
   { name: 'title', type: { kind: 'string' } },
   { name: 'status', type: { kind: 'enum', values: ['draft', 'published'] } },
 ])
-await channel.alterCollection('article', [...updatedProps])
+await channel.alterCollection('article', updatedFields)
 await channel.dropCollection('article')
 
 // Undo/Redo
@@ -403,7 +452,7 @@ await channel.renameConversation('Research')
 // Conversation handles (reactive interactions for specific conversations)
 const thread = channel.conversation('thread-42');
 await thread.prompt('Hello');        // Uses thread-42's interaction history
-// thread.interactions is reactive $state — auto-updates via SSE
+// thread.interactions is reactive $state — updates from space/channel events
 thread.close();                      // Stop listening when done
 
 // Channel admin
@@ -415,17 +464,23 @@ See the [SDK documentation](../sdk/README.md) for complete API details.
 ### Utilities
 
 ```typescript
-import { generateId } from '@rool-dev/svelte';
+import { machinePath, machineUri, isObjectPath, generateId } from '@rool-dev/svelte';
+
+machinePath('rool-machine:/rool-drive/docs/read%20me.md');
+// '/rool-drive/docs/read me.md'
 
-// Generate a 6-character alphanumeric ID
-const id = generateId();
+machineUri('/space/article/welcome.json');
+// 'rool-machine:/space/article/welcome.json'
+
+isObjectPath('/space/article/welcome.json'); // true
+generateId(); // 6-character alphanumeric ID
 ```
 
 ## Exported Types
 
 ```typescript
 // Package types
-import type { Rool, ReactiveChannel, ReactiveConversationHandle, ReactiveObject, ReactiveWatch, WatchOptions, ReactiveChannelList } from '@rool-dev/svelte';
+import type { Rool, ReactiveSpace, ReactiveChannel, ReactiveConversationHandle, ReactiveObject, ReactiveWatch, WatchOptions, ReactiveChannelList, ReactiveFileTree, ReactiveFileNode, ReactiveFileRoot, ReactiveFileTreeEvent, ReactiveFileTreeSyncResult } from '@rool-dev/svelte';
 
 // Re-exported from @rool-dev/sdk
 import type {
@@ -435,6 +490,7 @@ import type {
   RoolSpace,
   RoolSpaceInfo,
   RoolObject,
+  GetObjectsResult,
   RoolObjectStat,
   RoolUserRole,
   ConnectionState,
@@ -443,29 +499,27 @@ import type {
   ConversationInfo,
   CurrentUser,
   Interaction,
-  FindObjectsOptions,
   PromptOptions,
-  CreateObjectOptions,
+  PromptAttachment,
   UpdateObjectOptions,
+  MoveObjectOptions,
+  CollectionOptions,
   FieldType,
   FieldDef,
   CollectionDef,
   SpaceSchema,
   SpaceMember,
   UserResult,
-  PublishedExtensionInfo,
-  PublishExtensionOptions,
-  ExtensionManifest,
-  FindExtensionsOptions,
-
+  SpaceFileStorageUsage,
+  RoolSpaceEvents,
+  WebDAVDepth,
+  WebDAVSyncLevel,
+  WebDAVPropName,
+  WebDAVResponse,
+  WebDAVProps,
 } from '@rool-dev/svelte';
 ```
 
-## Examples
-
-- [soft-sql](../../examples/soft-sql) — SQL-style natural language queries with live tool call progress
-- [flashcards](../../examples/flashcards) — Spaced repetition with AI-generated cards
-
 ## License
 
 MIT - see [LICENSE](../../LICENSE) for details.

package/dist/channel.svelte.d.ts

@@ -1,12 +1,13 @@
 import type { RoolChannel, RoolSpace, Interaction, RoolObject, ChannelInfo, ConversationInfo, ConversationHandle } from '@rool-dev/sdk';
+import { ReactiveFileTree } from './file-tree.svelte.js';
 /**
  * Options for creating a reactive watch.
- * Same as FindObjectsOptions but without `prompt` (AI queries are too slow for reactive updates).
+ * Structured object filter for reactive updates.
  */
 export interface WatchOptions {
     /** Field requirements for exact matching */
     where?: Record<string, unknown>;
-    /** Filter by collection name. Returns objects whose `type` field equals the given name. */
+    /** Filter by collection name. */
     collection?: string;
     /** Maximum number of objects */
     limit?: number;
@@ -14,20 +15,15 @@ export interface WatchOptions {
     order?: 'asc' | 'desc';
 }
 /**
- * A reactive watch of objects that auto-updates when matching objects change.
+ * A reactive watch of objects that auto-updates when matching object files change.
  */
 declare class ReactiveWatchImpl {
     #private;
     objects: RoolObject[];
     loading: boolean;
-    constructor(channel: RoolChannel, options: WatchOptions);
-    /**
-     * Re-fetch the watched objects from the channel.
-     */
+    constructor(channel: RoolChannel, fileTree: ReactiveFileTree, options: WatchOptions);
+    /** Re-fetch matching objects using the canonical file tree for paths. */
     refresh(): Promise<void>;
-    /**
-     * Stop listening for updates and clean up.
-     */
     close(): void;
 }
 export type ReactiveWatch = ReactiveWatchImpl;
@@ -38,23 +34,11 @@ declare class ReactiveObjectImpl {
     #private;
     data: RoolObject | undefined;
     loading: boolean;
-    constructor(channel: RoolChannel, objectId: string);
-    /**
-     * Re-fetch the object from the channel.
-     */
+    constructor(channel: RoolChannel, fileTree: ReactiveFileTree, path: string);
     refresh(): Promise<void>;
-    /**
-     * Stop listening for updates and clean up.
-     */
     close(): void;
 }
 export type ReactiveObject = ReactiveObjectImpl;
-/**
- * A reactive conversation handle that auto-updates interactions when the
- * conversation changes. Wraps the SDK's ConversationHandle with $state.
- *
- * Call `close()` when done to stop listening for updates.
- */
 declare class ReactiveConversationHandleImpl {
     #private;
     interactions: Interaction[];
@@ -67,30 +51,30 @@ declare class ReactiveConversationHandleImpl {
     getSystemInstruction(): string | undefined;
     setSystemInstruction(...args: Parameters<ConversationHandle['setSystemInstruction']>): Promise<void>;
     rename(...args: Parameters<ConversationHandle['rename']>): Promise<void>;
-    findObjects(...args: Parameters<ConversationHandle['findObjects']>): Promise<{
-        objects: RoolObject[];
+    putObject(...args: Parameters<ConversationHandle['putObject']>): Promise<{
+        object: RoolObject;
         message: string;
     }>;
-    createObject(...args: Parameters<ConversationHandle['createObject']>): Promise<{
+    patchObject(...args: Parameters<ConversationHandle['patchObject']>): Promise<{
         object: RoolObject;
         message: string;
     }>;
-    updateObject(...args: Parameters<ConversationHandle['updateObject']>): Promise<{
+    moveObject(...args: Parameters<ConversationHandle['moveObject']>): Promise<{
         object: RoolObject;
         message: string;
     }>;
     deleteObjects(...args: Parameters<ConversationHandle['deleteObjects']>): Promise<void>;
+    /** @deprecated Use deleteObjects instead. */
+    deletePaths(...args: Parameters<ConversationHandle['deletePaths']>): Promise<void>;
     prompt(...args: Parameters<ConversationHandle['prompt']>): Promise<{
         message: string;
         objects: RoolObject[];
     }>;
+    stop(): Promise<boolean>;
     createCollection(...args: Parameters<ConversationHandle['createCollection']>): Promise<import("@rool-dev/sdk").CollectionDef>;
     alterCollection(...args: Parameters<ConversationHandle['alterCollection']>): Promise<import("@rool-dev/sdk").CollectionDef>;
     dropCollection(...args: Parameters<ConversationHandle['dropCollection']>): Promise<void>;
     setMetadata(...args: Parameters<ConversationHandle['setMetadata']>): void;
-    /**
-     * Stop listening for updates and clean up.
-     */
     close(): void;
 }
 export type ReactiveConversationHandle = ReactiveConversationHandleImpl;
@@ -101,10 +85,10 @@ export type ReactiveConversationHandle = ReactiveConversationHandleImpl;
 declare class ReactiveChannelImpl {
     #private;
     interactions: Interaction[];
-    objectIds: string[];
+    objectPaths: string[];
     collections: string[];
     conversations: ConversationInfo[];
-    constructor(channel: RoolChannel);
+    constructor(channel: RoolChannel, fileTree: ReactiveFileTree);
     get id(): string;
     get name(): string;
     get role(): import("@rool-dev/sdk").RoolUserRole;
@@ -113,30 +97,32 @@ declare class ReactiveChannelImpl {
     get channelName(): string | null;
     get isReadOnly(): boolean;
     get linkAccess(): import("@rool-dev/sdk").LinkAccess;
-    get extensionUrl(): string | null;
-    get manifest(): import("@rool-dev/sdk").ExtensionManifest | null;
     get isClosed(): boolean;
     close(): void;
     getObject(...args: Parameters<RoolChannel['getObject']>): Promise<RoolObject | undefined>;
+    getObjects(...args: Parameters<RoolChannel['getObjects']>): Promise<import("@rool-dev/sdk").GetObjectsResult>;
     stat(...args: Parameters<RoolChannel['stat']>): import("@rool-dev/sdk").RoolObjectStat | undefined;
-    findObjects(...args: Parameters<RoolChannel['findObjects']>): Promise<{
-        objects: RoolObject[];
+    putObject(...args: Parameters<RoolChannel['putObject']>): Promise<{
+        object: RoolObject;
         message: string;
     }>;
-    getObjectIds(...args: Parameters<RoolChannel['getObjectIds']>): string[];
-    createObject(...args: Parameters<RoolChannel['createObject']>): Promise<{
+    patchObject(...args: Parameters<RoolChannel['patchObject']>): Promise<{
         object: RoolObject;
         message: string;
     }>;
-    updateObject(...args: Parameters<RoolChannel['updateObject']>): Promise<{
+    moveObject(...args: Parameters<RoolChannel['moveObject']>): Promise<{
         object: RoolObject;
         message: string;
     }>;
     deleteObjects(...args: Parameters<RoolChannel['deleteObjects']>): Promise<void>;
+    /** @deprecated Use deleteObjects instead. */
+    deletePaths(...args: Parameters<RoolChannel['deletePaths']>): Promise<void>;
     prompt(...args: Parameters<RoolChannel['prompt']>): Promise<{
         message: string;
         objects: RoolObject[];
     }>;
+    stop(): Promise<boolean>;
+    stopInteraction(...args: Parameters<RoolChannel['stopInteraction']>): Promise<boolean>;
     checkpoint(...args: Parameters<RoolChannel['checkpoint']>): Promise<string>;
     canUndo(): Promise<boolean>;
     canRedo(): Promise<boolean>;
@@ -159,45 +145,31 @@ declare class ReactiveChannelImpl {
     createCollection(...args: Parameters<RoolChannel['createCollection']>): Promise<import("@rool-dev/sdk").CollectionDef>;
     alterCollection(...args: Parameters<RoolChannel['alterCollection']>): Promise<import("@rool-dev/sdk").CollectionDef>;
     dropCollection(...args: Parameters<RoolChannel['dropCollection']>): Promise<void>;
-    uploadMedia(...args: Parameters<RoolChannel['uploadMedia']>): Promise<string>;
-    fetchMedia(...args: Parameters<RoolChannel['fetchMedia']>): Promise<import("@rool-dev/sdk").MediaResponse>;
-    deleteMedia(...args: Parameters<RoolChannel['deleteMedia']>): Promise<void>;
-    listMedia(): Promise<import("@rool-dev/sdk").MediaInfo[]>;
     fetch(...args: Parameters<RoolChannel['fetch']>): Promise<Response>;
     rename(...args: Parameters<RoolChannel['rename']>): Promise<void>;
     conversation(conversationId: string): ReactiveConversationHandle;
     on(...args: Parameters<RoolChannel['on']>): () => void;
     off(...args: Parameters<RoolChannel['off']>): void;
     /**
-     * Create a reactive object that auto-updates when the object changes.
-     * Throws if the channel has been closed.
+     * Create a reactive object that auto-updates when the object at this path changes.
      */
-    object(objectId: string): ReactiveObject;
+    object(path: string): ReactiveObject;
     /**
      * Create a reactive watch that auto-updates when matching objects change.
-     * Throws if the channel has been closed.
      */
     watch(options: WatchOptions): ReactiveWatch;
 }
-export declare function wrapChannel(channel: RoolChannel): ReactiveChannel;
+export declare function wrapChannel(channel: RoolChannel, fileTree: ReactiveFileTree): ReactiveChannel;
 export type ReactiveChannel = ReactiveChannelImpl;
 /**
  * A reactive list of channels for a space that auto-updates via SSE events.
- * Can be constructed with a RoolSpace directly or a Promise<RoolSpace>
- * (starts with an empty list and loading=true until the space resolves).
  */
 declare class ReactiveChannelListImpl {
     #private;
     list: ChannelInfo[];
     loading: boolean;
     constructor(spaceOrPromise: RoolSpace | Promise<RoolSpace>);
-    /**
-     * Refresh the channel list from the space.
-     */
     refresh(): Promise<void>;
-    /**
-     * Stop listening for updates and clean up.
-     */
     close(): void;
 }
 export declare function createChannelList(spaceOrPromise: RoolSpace | Promise<RoolSpace>): ReactiveChannelList;