@rool-dev/sdk 0.10.1 → 0.10.2-dev.0bf8edb

package/dist/channel.js

@@ -1,8 +1,9 @@
 import { EventEmitter } from './event-emitter.js';
-import { generateBasename, loc, normalizeLocation, parseLocation } from './locations.js';
-import { resolveMachineResource } from './machine.js';
-// 6-character alphanumeric ID — used for interactionIds, conversationIds, etc.
+import { WebDAVError } from './webdav.js';
+import { isObjectPath, machinePath, machineUri } from './path.js';
+// 6-character alphanumeric ID — used for object names, interactionIds, conversationIds, etc.
 const ENTITY_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+const GET_OBJECTS_CHUNK_SIZE = 500;
 export function generateEntityId() {
     let result = '';
     for (let i = 0; i < 6; i++) {
@@ -42,6 +43,45 @@ function findDefaultLeaf(interactions) {
     }
     return best?.id;
 }
+function objectPath(input) {
+    const path = machinePath(input);
+    if (!isObjectPath(path)) {
+        throw new Error(`Object path must be /space/<collection>/<name>.json without dotfiles: ${input}`);
+    }
+    return path;
+}
+function collectionPath(name) {
+    return machinePath(`/space/${name}`);
+}
+function schemaPath(name) {
+    return `${collectionPath(name)}/.schema.json`;
+}
+function objectFromBody(path, body) {
+    return { path, body };
+}
+function jsonObject(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a JSON object`);
+    }
+    return value;
+}
+function patchBody(current, patch) {
+    const next = { ...current };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null || value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return next;
+}
+function collectionDef(input, options) {
+    const base = Array.isArray(input)
+        ? { fields: input }
+        : { fields: input.fields, schemaOrgType: input.schemaOrgType };
+    const schemaOrgType = options?.schemaOrgType ?? base.schemaOrgType;
+    return schemaOrgType ? { fields: base.fields, schemaOrgType } : { fields: base.fields };
+}
 function attachmentBody(file) {
     if (isFile(file)) {
         return {
@@ -59,7 +99,7 @@ function attachmentBody(file) {
         };
     }
     return {
-        filename: safeAttachmentFilename('attachment', file.contentType),
+        filename: safeAttachmentFilename(file.filename ?? 'attachment', file.contentType),
         contentType: file.contentType,
         body: base64Body(file.data),
     };
@@ -115,8 +155,6 @@ function base64Body(data) {
         bytes[i] = binary.charCodeAt(i);
     return bytes.buffer;
 }
-// Default timeout for waiting on SSE object events (30 seconds)
-const OBJECT_COLLECT_TIMEOUT = 30000;
 /**
  * A channel is a space + channelId pair.
  *
@@ -124,10 +162,10 @@ const OBJECT_COLLECT_TIMEOUT = 30000;
  * at open time and cannot be changed. To use a different channel,
  * open a second one.
  *
- * Objects are addressed by location (`/space/<collection>/<basename>.json`).
- * Only schema, metadata, the live object location list, and the channel's own
- * history are cached locally. Object bodies are fetched on demand. Changes
- * arrive via SSE semantic events and are emitted as SDK events.
+ * 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.
  */
 export class RoolChannel extends EventEmitter {
     _id;
@@ -143,21 +181,13 @@ export class RoolChannel extends EventEmitter {
     webdav;
     onCloseCallback;
     logger;
-    // Local cache for bounded data (schema, metadata, own channel, object locations, stats)
+    // Local cache for bounded data (schema, metadata, own channel, object stats)
     _meta;
     _schema;
     _channel;
-    _objectLocations;
     _objectStats;
     // Active leaf per conversation (client-side tree cursor)
     _activeLeaves = new Map();
-    // Object collection: tracks pending local mutations (by location) for dedup
-    // Maps location → optimistic object (for create/update) or null (for delete)
-    _pendingMutations = new Map();
-    // Resolvers waiting for object data from SSE events, keyed by location
-    _objectResolvers = new Map();
-    // Buffer for object data that arrived before a collector was registered, keyed by location
-    _objectBuffer = new Map();
     constructor(config) {
         super();
         this._id = config.id;
@@ -176,8 +206,7 @@ export class RoolChannel extends EventEmitter {
         // Initialize local cache from server data
         this._meta = config.meta;
         this._schema = config.schema;
-        this._channel = config.channel;
-        this._objectLocations = config.objectLocations;
+        this._channel = config.channel ?? undefined;
         this._objectStats = new Map(Object.entries(config.objectStats));
     }
     /**
@@ -198,7 +227,6 @@ export class RoolChannel extends EventEmitter {
             return;
         this._meta = data.meta;
         this._schema = data.schema;
-        this._objectLocations = data.objectLocations;
         this._objectStats = new Map(Object.entries(data.objectStats));
         if (data.channel)
             this._channel = data.channel;
@@ -244,24 +272,6 @@ export class RoolChannel extends EventEmitter {
     get isReadOnly() {
         return this._role === 'viewer';
     }
-    /**
-     * Get the extension URL if this channel was created via installExtension, or null.
-     */
-    get extensionUrl() {
-        return this._channel?.extensionUrl ?? null;
-    }
-    /**
-     * Get the extension ID if this channel has an installed extension, or null.
-     */
-    get extensionId() {
-        return this._channel?.extensionId ?? null;
-    }
-    /**
-     * Get the extension manifest if this channel has an installed extension, or null.
-     */
-    get manifest() {
-        return this._channel?.manifest ?? null;
-    }
     /**
      * Get the active branch of the current conversation as a flat array (root → leaf).
      * Walks from the active leaf up through parentId pointers.
@@ -376,10 +386,6 @@ export class RoolChannel extends EventEmitter {
     close() {
         this._closed = true;
         this.onCloseCallback();
-        // Clean up pending object collectors
-        this._objectResolvers.clear();
-        this._objectBuffer.clear();
-        this._pendingMutations.clear();
         this.removeAllListeners();
     }
     /**
@@ -413,208 +419,165 @@ export class RoolChannel extends EventEmitter {
     async clearHistory() {
         await this.graphqlClient.clearCheckpointHistory(this._id, this._channelId);
     }
-    /**
-     * Get an object by location. Fetches from the server on each call.
-     *
-     * Accepts either the canonical form (`/space/<collection>/<basename>.json`)
-     * or the short form (`<collection>/<basename>`).
-     */
-    async getObject(location) {
-        return this.graphqlClient.getObject(this._id, normalizeLocation(location));
-    }
-    /**
-     * Get an object's stat (audit information).
-     * Returns the cached stat or undefined if not known.
-     */
-    stat(location) {
-        return this._objectStats.get(normalizeLocation(location));
-    }
-    /**
-     * Find objects using structured filters and/or natural language.
-     */
-    async findObjects(options) {
-        return this._findObjectsImpl(options, this._conversationId);
+    davHeaders(conversationId, interactionId) {
+        const headers = new Headers({
+            'X-Rool-Channel-Id': this._channelId,
+            'X-Rool-Conversation-Id': conversationId,
+        });
+        if (interactionId)
+            headers.set('X-Rool-Interaction-Id', interactionId);
+        return headers;
     }
-    /** @internal */
-    _findObjectsImpl(options, conversationId) {
-        const normalized = {
-            ...options,
-            locations: options.locations?.map(normalizeLocation),
-        };
-        return this.graphqlClient.findObjects(this._id, normalized, this._channelId, conversationId);
+    async readObject(path) {
+        const canonical = objectPath(path);
+        try {
+            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') };
+        }
+        catch (error) {
+            if (error instanceof WebDAVError && error.status === 404)
+                return undefined;
+            if (error instanceof SyntaxError)
+                throw new Error(`Object ${canonical} did not contain valid JSON`);
+            throw error;
+        }
     }
-    /**
-     * Get all object locations (sync, from local cache).
-     * The list is loaded on open and kept current via SSE events.
-     */
-    getObjectLocations(options) {
-        let locs = this._objectLocations;
-        if (options?.order === 'asc') {
-            locs = [...locs].reverse();
+    /** Get an object JSON file by machine path. Fetches from the server on each call. */
+    async getObject(path) {
+        return (await this.readObject(path))?.object;
+    }
+    /** Get object JSON files by machine path in bulk. Duplicate paths are fetched once. */
+    async getObjects(paths) {
+        const canonical = [];
+        const seen = new Set();
+        for (const path of paths) {
+            const normalized = objectPath(path);
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            canonical.push(normalized);
         }
-        if (options?.limit !== undefined) {
-            locs = locs.slice(0, options.limit);
+        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);
+            result.objects.push(...partial.objects);
+            result.missing.push(...partial.missing);
         }
-        return locs;
+        return result;
     }
-    /**
-     * Create a new object in the given collection.
-     *
-     * @param collection - The collection (must exist in the schema)
-     * @param body - Object body fields. Use `{{placeholder}}` for AI-generated content.
-     *               Fields prefixed with `_` are hidden from AI.
-     * @param options.basename - Specific basename to use. If omitted, the SDK generates a random one.
-     * @param options.ephemeral - If true, the operation won't be recorded in interaction history.
-     * @returns The created object and a status message.
-     */
-    async createObject(collection, body, options) {
-        return this._createObjectImpl(collection, body, options, this._conversationId);
+    /** Get an object's cached audit information. */
+    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 _createObjectImpl(collection, body, options, conversationId) {
-        const basename = options?.basename ?? generateBasename();
-        const location = loc(collection, basename);
-        const optimistic = { location, collection, basename, body };
-        this._pendingMutations.set(location, optimistic);
-        this.emit('objectCreated', { location, object: optimistic, source: 'local_user' });
+    async _putObjectImpl(path, body, conversationId) {
+        const canonical = objectPath(path);
+        const optimistic = objectFromBody(canonical, body);
         try {
             const interactionId = generateEntityId();
-            const { message, object } = await this.graphqlClient.createObject(this._id, location, body, this._channelId, conversationId, interactionId, { ephemeral: options?.ephemeral, parentInteractionId: options?.parentInteractionId });
-            const fresh = object ?? await this._collectObject(location);
-            return { object: fresh, message };
+            await this.webdav.put(canonical, JSON.stringify(body), {
+                contentType: 'application/json',
+                headers: this.davHeaders(conversationId, interactionId),
+            });
+            const fresh = await this.getObject(canonical) ?? optimistic;
+            return { object: fresh, message: `Put ${canonical}` };
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to create object:', error);
-            this._pendingMutations.delete(location);
-            this._cancelCollector(location);
+            this.logger.error('[RoolChannel] Failed to put object:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
-            this.emit('reset', { source: 'system' });
             throw error;
         }
     }
-    /**
-     * Update an existing object.
-     *
-     * @param location - The object's location (canonical or short form)
-     * @param options.data - Fields to add or update. Pass `null` to delete a field. Use `{{placeholder}}` for AI-generated content.
-     * @param options.prompt - AI prompt to drive the update.
-     * @param options.ephemeral - If true, the operation won't be recorded in interaction history.
-     */
-    async updateObject(location, options) {
-        return this._updateObjectImpl(location, options, this._conversationId);
+    /** Patch an existing object. Null or undefined deletes a field. */
+    async patchObject(path, options) {
+        return this._patchObjectImpl(path, options, this._conversationId);
     }
     /** @internal */
-    async _updateObjectImpl(location, options, conversationId) {
-        const canonical = normalizeLocation(location);
-        const { data } = options;
-        // Normalize undefined to null (for JSON serialization) and build server patch
-        let serverPatch;
-        if (data) {
-            serverPatch = {};
-            for (const [key, value] of Object.entries(data)) {
-                serverPatch[key] = value === undefined ? null : value;
-            }
-        }
-        // Emit optimistic event if we have data changes
-        if (data) {
-            const { collection, basename } = parseLocation(canonical);
-            const optimistic = { location: canonical, collection, basename, body: data };
-            this._pendingMutations.set(canonical, optimistic);
-            this.emit('objectUpdated', { location: canonical, object: optimistic, source: 'local_user' });
-        }
+    async _patchObjectImpl(path, options, conversationId) {
+        const canonical = objectPath(path);
+        const data = options.data ?? {};
+        const current = await this.readObject(canonical);
+        if (!current)
+            throw new Error(`Object ${canonical} not found`);
+        const body = patchBody(current.object.body, data);
+        const optimistic = objectFromBody(canonical, body);
         try {
             const interactionId = generateEntityId();
-            const { message, object } = await this.graphqlClient.updateObject(this._id, canonical, this._channelId, conversationId, interactionId, {
-                patch: serverPatch,
-                prompt: options.prompt,
-                ephemeral: options.ephemeral,
-                parentInteractionId: options.parentInteractionId,
+            await this.webdav.put(canonical, JSON.stringify(body), {
+                contentType: 'application/json',
+                ifMatch: current.etag ?? undefined,
+                headers: this.davHeaders(conversationId, interactionId),
             });
-            const fresh = object ?? await this._collectObject(canonical);
-            return { object: fresh, message };
+            const fresh = await this.getObject(canonical) ?? optimistic;
+            return { object: fresh, message: `Patched ${canonical}` };
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to update object:', error);
-            this._pendingMutations.delete(canonical);
-            this._cancelCollector(canonical);
+            this.logger.error('[RoolChannel] Failed to patch object:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
-            this.emit('reset', { source: 'system' });
             throw error;
         }
     }
-    /**
-     * Move (rename or relocate) an object to a new location.
-     * Use this to rename, change collection, or atomically rewrite the body.
-     *
-     * @param from - Current location
-     * @param to - New location
-     * @param options.body - Replace the body atomically as part of the move.
-     * @param options.ephemeral - If true, the operation won't be recorded in interaction history.
-     */
+    /** 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 fromLoc = normalizeLocation(from);
-        const toLoc = normalizeLocation(to);
-        // Optimistic event — emit move so listeners can update keys
-        const { collection, basename } = parseLocation(toLoc);
-        const optimistic = {
-            location: toLoc,
-            collection,
-            basename,
-            body: options?.body ?? {},
-        };
-        this._pendingMutations.set(toLoc, optimistic);
-        this.emit('objectMoved', { from: fromLoc, to: toLoc, object: optimistic, source: 'local_user' });
+        const fromPath = objectPath(from);
+        const toPath = objectPath(to);
+        const optimistic = objectFromBody(toPath, options?.body ?? {});
         try {
             const interactionId = generateEntityId();
-            const { message, object } = await this.graphqlClient.moveObject(this._id, fromLoc, toLoc, this._channelId, conversationId, interactionId, {
-                body: options?.body,
-                ephemeral: options?.ephemeral,
-                parentInteractionId: options?.parentInteractionId,
+            await this.webdav.move(fromPath, toPath, {
+                headers: this.davHeaders(conversationId, interactionId),
             });
-            const fresh = object ?? await this._collectObject(toLoc);
-            return { object: fresh, message };
+            if (options?.body) {
+                await this.webdav.put(toPath, JSON.stringify(options.body), {
+                    contentType: 'application/json',
+                    headers: this.davHeaders(conversationId, interactionId),
+                });
+            }
+            this._objectStats.delete(fromPath);
+            const fresh = await this.getObject(toPath) ?? optimistic;
+            return { object: fresh, message: `Moved ${fromPath} to ${toPath}` };
         }
         catch (error) {
             this.logger.error('[RoolChannel] Failed to move object:', error);
-            this._pendingMutations.delete(toLoc);
-            this._cancelCollector(toLoc);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
-            this.emit('reset', { source: 'system' });
             throw error;
         }
     }
-    /**
-     * Delete objects by location.
-     * Other objects that reference deleted objects will retain stale ref values.
-     */
-    async deleteObjects(locations) {
-        return this._deleteObjectsImpl(locations, this._conversationId);
+    /** 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(locations, conversationId) {
-        if (locations.length === 0)
+    async _deleteObjectsImpl(paths, conversationId) {
+        if (paths.length === 0)
             return;
-        const canonical = locations.map(normalizeLocation);
-        // Track for dedup and emit optimistic events
-        for (const location of canonical) {
-            this._pendingMutations.set(location, null);
-            this.emit('objectDeleted', { location, source: 'local_user' });
-        }
+        const canonical = paths.map(objectPath);
         try {
             const interactionId = generateEntityId();
-            await this.graphqlClient.deleteObjects(this._id, canonical, this._channelId, conversationId, interactionId);
+            for (const path of canonical) {
+                await this.webdav.delete(path, {
+                    headers: this.davHeaders(conversationId, interactionId),
+                });
+                this._objectStats.delete(path);
+            }
         }
         catch (error) {
-            this.logger.error('[RoolChannel] Failed to delete objects:', error);
-            for (const location of canonical) {
-                this._pendingMutations.delete(location);
-            }
+            this.logger.error('[RoolChannel] Failed to delete paths:', error);
             this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
-            this.emit('reset', { source: 'system' });
             throw error;
         }
     }
@@ -623,19 +586,25 @@ export class RoolChannel extends EventEmitter {
         return this._schema;
     }
     /** Create a new collection schema. */
-    async createCollection(name, fields) {
-        return this._createCollectionImpl(name, fields, this._conversationId);
+    async createCollection(name, fields, options) {
+        return this._createCollectionImpl(name, fields, options, this._conversationId);
     }
     /** @internal */
-    async _createCollectionImpl(name, fields, conversationId) {
+    async _createCollectionImpl(name, fields, options, conversationId) {
         if (this._schema[name]) {
             throw new Error(`Collection "${name}" already exists`);
         }
         // Optimistic local update
-        const optimisticDef = { fields: fields.map(f => ({ name: f.name, type: f.type })) };
+        const optimisticDef = collectionDef(fields, options);
         this._schema[name] = optimisticDef;
         try {
-            return await this.graphqlClient.createCollection(this._id, name, fields, this._channelId, conversationId);
+            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()),
+            });
+            this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
+            return optimisticDef;
         }
         catch (error) {
             this.logger.error('[RoolChannel] Failed to create collection:', error);
@@ -644,18 +613,24 @@ export class RoolChannel extends EventEmitter {
         }
     }
     /** Alter an existing collection schema, replacing its field definitions. */
-    async alterCollection(name, fields) {
-        return this._alterCollectionImpl(name, fields, this._conversationId);
+    async alterCollection(name, fields, options) {
+        return this._alterCollectionImpl(name, fields, options, this._conversationId);
     }
     /** @internal */
-    async _alterCollectionImpl(name, fields, conversationId) {
+    async _alterCollectionImpl(name, fields, options, conversationId) {
         if (!this._schema[name]) {
             throw new Error(`Collection "${name}" not found`);
         }
         const previous = this._schema[name];
-        this._schema[name] = { fields: fields.map(f => ({ name: f.name, type: f.type })) };
+        this._schema[name] = collectionDef(fields, options);
         try {
-            return await this.graphqlClient.alterCollection(this._id, name, fields, this._channelId, conversationId);
+            const updated = this._schema[name];
+            await this.webdav.put(schemaPath(name), JSON.stringify(updated), {
+                contentType: 'application/json',
+                headers: this.davHeaders(conversationId, generateEntityId()),
+            });
+            this.emit('schemaUpdated', { schema: this._schema, source: 'local_user' });
+            return updated;
         }
         catch (error) {
             this.logger.error('[RoolChannel] Failed to alter collection:', error);
@@ -675,7 +650,8 @@ export class RoolChannel extends EventEmitter {
         const previous = this._schema[name];
         delete this._schema[name];
         try {
-            await this.graphqlClient.dropCollection(this._id, name, this._channelId, conversationId);
+            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);
@@ -811,12 +787,14 @@ export class RoolChannel extends EventEmitter {
     }
     /** @internal */
     async _promptImpl(prompt, options, conversationId) {
-        const { attachments, parentInteractionId: explicitParent, signal, locations, ...rest } = options ?? {};
+        const { attachments, parentInteractionId: explicitParent, signal, ...rest } = options ?? {};
         const interactionId = generateEntityId();
         let attachmentRefs;
         if (attachments?.length) {
-            const resources = await Promise.all(attachments.map((file) => this.uploadAttachment(file, conversationId)));
-            attachmentRefs = resources.map((resource) => `rool-machine:${resource.path.split('/').map(encodeURIComponent).join('/')}`);
+            attachmentRefs = await Promise.all(attachments.map(async (attachment) => {
+                const path = typeof attachment === 'string' ? machinePath(attachment) : await this.uploadAttachment(attachment, conversationId);
+                return machineUri(path);
+            }));
         }
         // Auto-continue from active leaf if no explicit parent provided
         const parentInteractionId = explicitParent !== undefined
@@ -840,7 +818,6 @@ export class RoolChannel extends EventEmitter {
         try {
             result = await this.graphqlClient.prompt(this._id, prompt, this._channelId, conversationId, {
                 ...rest,
-                locations: locations?.map(normalizeLocation),
                 attachmentRefs,
                 interactionId,
                 parentInteractionId,
@@ -850,25 +827,11 @@ export class RoolChannel extends EventEmitter {
             if (onAbort)
                 signal.removeEventListener('abort', onAbort);
         }
-        // Collect modified objects — they arrive via SSE events during/after the mutation.
         const objects = [];
-        const missing = [];
-        for (const location of result.modifiedObjectLocations) {
-            const buffered = this._objectBuffer.get(location);
-            if (buffered) {
-                this._objectBuffer.delete(location);
-                objects.push(buffered);
-            }
-            else {
-                missing.push(location);
-            }
-        }
-        if (missing.length > 0) {
-            const fetched = await Promise.all(missing.map(location => this.graphqlClient.getObject(this._id, location)));
-            for (const obj of fetched) {
-                if (obj)
-                    objects.push(obj);
-            }
+        const fetched = await Promise.all(result.modifiedObjectPaths.map((path) => this.getObject(path)));
+        for (const object of fetched) {
+            if (object)
+                objects.push(object);
         }
         return {
             message: result.message,
@@ -900,70 +863,20 @@ export class RoolChannel extends EventEmitter {
         return this.restClient.proxyFetch(this._id, url, init);
     }
     async uploadAttachment(file, conversationId) {
-        await this.ensureCollection('attachments');
-        const directory = `attachments/${conversationId}`;
+        await this.ensureCollection('/rool-drive/attachments');
+        const directory = `/rool-drive/attachments/${conversationId}`;
         await this.ensureCollection(directory);
         const attachment = attachmentBody(file);
         const path = `${directory}/${attachment.filename}`;
         await this.webdav.put(path, attachment.body, { contentType: attachment.contentType });
-        const resource = resolveMachineResource(`/rool-drive/${path}`);
-        if (!resource)
-            throw new Error('Failed to resolve uploaded attachment');
-        return resource;
+        return path;
     }
     async ensureCollection(path) {
-        // Note: not an object collection, a folder, which is "collection" in webdav land
         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()}`);
     }
-    /**
-     * Register a collector that resolves when the object arrives via SSE.
-     * @internal
-     */
-    _collectObject(location) {
-        return new Promise((resolve, reject) => {
-            const buffered = this._objectBuffer.get(location);
-            if (buffered) {
-                this._objectBuffer.delete(location);
-                resolve(buffered);
-                return;
-            }
-            const timer = setTimeout(() => {
-                this._objectResolvers.delete(location);
-                // Fallback: try to fetch from server
-                this.graphqlClient.getObject(this._id, location).then(obj => {
-                    if (obj) {
-                        resolve(obj);
-                    }
-                    else {
-                        reject(new Error(`Timeout waiting for object ${location} from SSE`));
-                    }
-                }).catch(reject);
-            }, OBJECT_COLLECT_TIMEOUT);
-            this._objectResolvers.set(location, (obj) => {
-                clearTimeout(timer);
-                resolve(obj);
-            });
-        });
-    }
-    /** @internal */
-    _cancelCollector(location) {
-        this._objectResolvers.delete(location);
-        this._objectBuffer.delete(location);
-    }
-    /** @internal */
-    _deliverObject(location, object) {
-        const resolver = this._objectResolvers.get(location);
-        if (resolver) {
-            resolver(object);
-            this._objectResolvers.delete(location);
-        }
-        else {
-            this._objectBuffer.set(location, object);
-        }
-    }
     /**
      * Handle a channel event from the subscription.
      * @internal
@@ -976,34 +889,6 @@ export class RoolChannel extends EventEmitter {
             case 'connected':
                 // Resync is handled by the client via _applyResyncData.
                 break;
-            case 'object_created':
-                if (event.location && event.object) {
-                    if (event.objectStat)
-                        this._objectStats.set(event.location, event.objectStat);
-                    this._handleObjectCreated(event.location, event.object, changeSource);
-                }
-                break;
-            case 'object_updated':
-                if (event.location && event.object) {
-                    if (event.objectStat)
-                        this._objectStats.set(event.location, event.objectStat);
-                    this._handleObjectUpdated(event.location, event.object, changeSource);
-                }
-                break;
-            case 'object_deleted':
-                if (event.location) {
-                    this._objectStats.delete(event.location);
-                    this._handleObjectDeleted(event.location, changeSource);
-                }
-                break;
-            case 'object_moved':
-                if (event.from && event.to && event.object) {
-                    this._objectStats.delete(event.from);
-                    if (event.objectStat)
-                        this._objectStats.set(event.to, event.objectStat);
-                    this._handleObjectMoved(event.from, event.to, event.object, changeSource);
-                }
-                break;
             case 'schema_updated':
                 if (event.schema) {
                     this._schema = event.schema;
@@ -1025,6 +910,13 @@ export class RoolChannel extends EventEmitter {
                     }
                 }
                 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) {
@@ -1069,72 +961,6 @@ export class RoolChannel extends EventEmitter {
                 break;
         }
     }
-    /** @internal */
-    _handleObjectCreated(location, object, source) {
-        this._deliverObject(location, object);
-        // Maintain local location list — prepend (most recently modified first)
-        this._objectLocations = [location, ...this._objectLocations.filter(l => l !== location)];
-        const pending = this._pendingMutations.get(location);
-        if (pending !== undefined) {
-            this._pendingMutations.delete(location);
-            if (pending !== null) {
-                // Already emitted objectCreated optimistically.
-                // Emit objectUpdated only if AI resolved placeholders (data changed).
-                if (JSON.stringify(pending) !== JSON.stringify(object)) {
-                    this.emit('objectUpdated', { location, object, source });
-                }
-            }
-        }
-        else {
-            this.emit('objectCreated', { location, object, source });
-        }
-    }
-    /** @internal */
-    _handleObjectUpdated(location, object, source) {
-        this._deliverObject(location, object);
-        this._objectLocations = [location, ...this._objectLocations.filter(l => l !== location)];
-        const pending = this._pendingMutations.get(location);
-        if (pending !== undefined) {
-            this._pendingMutations.delete(location);
-            if (pending !== null) {
-                if (JSON.stringify(pending) !== JSON.stringify(object)) {
-                    this.emit('objectUpdated', { location, object, source });
-                }
-            }
-        }
-        else {
-            this.emit('objectUpdated', { location, object, source });
-        }
-    }
-    /** @internal */
-    _handleObjectDeleted(location, source) {
-        this._objectLocations = this._objectLocations.filter(l => l !== location);
-        const pending = this._pendingMutations.get(location);
-        if (pending !== undefined) {
-            this._pendingMutations.delete(location);
-        }
-        else {
-            this.emit('objectDeleted', { location, source });
-        }
-    }
-    /** @internal */
-    _handleObjectMoved(from, to, object, source) {
-        this._deliverObject(to, object);
-        // Drop old location, insert new one at the front.
-        this._objectLocations = [to, ...this._objectLocations.filter(l => l !== from && l !== to)];
-        const pending = this._pendingMutations.get(to);
-        if (pending !== undefined) {
-            this._pendingMutations.delete(to);
-            if (pending !== null) {
-                if (JSON.stringify(pending) !== JSON.stringify(object)) {
-                    this.emit('objectUpdated', { location: to, object, source });
-                }
-            }
-        }
-        else {
-            this.emit('objectMoved', { from, to, object, source });
-        }
-    }
 }
 /**
  * A lightweight handle for a specific conversation within a channel.
@@ -1178,37 +1004,37 @@ export class ConversationHandle {
     async rename(name) {
         return this._channel._renameConversationImpl(name, this._conversationId);
     }
-    /** Find objects using structured filters and/or natural language. */
-    async findObjects(options) {
-        return this._channel._findObjectsImpl(options, this._conversationId);
-    }
-    /** Create a new object. */
-    async createObject(collection, body, options) {
-        return this._channel._createObjectImpl(collection, body, options, this._conversationId);
+    /** Create or replace an object JSON file. */
+    async putObject(path, body) {
+        return this._channel._putObjectImpl(path, body, this._conversationId);
     }
-    /** Update an existing object. */
-    async updateObject(location, options) {
-        return this._channel._updateObjectImpl(location, options, this._conversationId);
+    /** Patch an existing object JSON file. */
+    async patchObject(path, options) {
+        return this._channel._patchObjectImpl(path, options, this._conversationId);
     }
     /** Move (rename/relocate) an object. */
     async moveObject(from, to, options) {
         return this._channel._moveObjectImpl(from, to, options, this._conversationId);
     }
-    /** Delete objects by location. */
-    async deleteObjects(locations) {
-        return this._channel._deleteObjectsImpl(locations, this._conversationId);
+    /** Delete object JSON files by path. */
+    async deleteObjects(paths) {
+        return this._channel._deleteObjectsImpl(paths, this._conversationId);
+    }
+    /** @deprecated Use deleteObjects instead. */
+    async deletePaths(paths) {
+        return this.deleteObjects(paths);
     }
     /** 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);
     }
     /** Create a new collection schema. */
-    async createCollection(name, fields) {
-        return this._channel._createCollectionImpl(name, fields, this._conversationId);
+    async createCollection(name, fields, options) {
+        return this._channel._createCollectionImpl(name, fields, options, this._conversationId);
     }
     /** Alter an existing collection schema. */
-    async alterCollection(name, fields) {
-        return this._channel._alterCollectionImpl(name, fields, this._conversationId);
+    async alterCollection(name, fields, options) {
+        return this._channel._alterCollectionImpl(name, fields, options, this._conversationId);
     }
     /** Drop a collection schema. */
     async dropCollection(name) {