@rool-dev/sdk 0.2.0-dev.f798776 → 0.3.0-dev.31aef9f

package/dist/channel.js

@@ -0,0 +1,793 @@
+import { EventEmitter } from './event-emitter.js';
+import { ChannelSubscriptionManager } from './subscription.js';
+// 6-character alphanumeric ID (62^6 = 56.8 billion possible values)
+const ID_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+export function generateEntityId() {
+    let result = '';
+    for (let i = 0; i < 6; i++) {
+        result += ID_CHARS[Math.floor(Math.random() * ID_CHARS.length)];
+    }
+    return result;
+}
+// Default timeout for waiting on SSE object events (30 seconds)
+const OBJECT_COLLECT_TIMEOUT = 30000;
+/**
+ * A channel is a space + channelId pair.
+ *
+ * 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 fetched on demand from the server; only schema, metadata,
+ * and the channel's own history are cached locally. Object changes
+ * arrive via SSE semantic events and are emitted as SDK events.
+ *
+ * Features:
+ * - High-level object operations
+ * - Built-in undo/redo with checkpoints
+ * - Metadata management
+ * - Event emission for state changes
+ * - Real-time updates via space-specific subscription
+ */
+export class RoolChannel extends EventEmitter {
+    _id;
+    _name;
+    _role;
+    _linkAccess;
+    _userId;
+    _channelId;
+    _closed = false;
+    graphqlClient;
+    mediaClient;
+    subscriptionManager;
+    onCloseCallback;
+    _subscriptionReady;
+    logger;
+    // Local cache for bounded data (schema, metadata, own channel, object IDs, stats)
+    _meta;
+    _schema;
+    _channel;
+    _objectIds;
+    _objectStats;
+    // Object collection: tracks pending local mutations for dedup
+    // Maps objectId → optimistic object data (for create/update) or null (for delete)
+    _pendingMutations = new Map();
+    // Resolvers waiting for object data from SSE events
+    _objectResolvers = new Map();
+    // Buffer for object data that arrived before a collector was registered
+    _objectBuffer = new Map();
+    constructor(config) {
+        super();
+        this._id = config.id;
+        this._name = config.name;
+        this._role = config.role;
+        this._linkAccess = config.linkAccess;
+        this._userId = config.userId;
+        this._emitterLogger = config.logger;
+        this._channelId = config.channelId;
+        this.graphqlClient = config.graphqlClient;
+        this.mediaClient = config.mediaClient;
+        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;
+        this._objectIds = config.objectIds;
+        this._objectStats = new Map(Object.entries(config.objectStats));
+        // Create channel subscription
+        this.subscriptionManager = new ChannelSubscriptionManager({
+            graphqlUrl: config.graphqlUrl,
+            authManager: config.authManager,
+            logger: this.logger,
+            spaceId: this._id,
+            channelId: this._channelId,
+            onEvent: (event) => this.handleChannelEvent(event),
+            onConnectionStateChanged: () => {
+                // Channel connection state (could emit events if needed)
+            },
+            onError: (error) => {
+                this.logger.error(`[RoolChannel ${this._id}] Subscription error:`, error);
+            },
+        });
+        // Start subscription - store promise for openChannel to await
+        this._subscriptionReady = this.subscriptionManager.subscribe();
+    }
+    /**
+     * Wait for the real-time subscription to be established.
+     * Called internally by openChannel/createSpace before returning the channel.
+     * @internal
+     */
+    _waitForSubscription() {
+        return this._subscriptionReady;
+    }
+    // ===========================================================================
+    // Properties
+    // ===========================================================================
+    get id() {
+        return this._id;
+    }
+    get name() {
+        return this._name;
+    }
+    get role() {
+        return this._role;
+    }
+    get linkAccess() {
+        return this._linkAccess;
+    }
+    /** Current user's ID (for identifying own interactions) */
+    get userId() {
+        return this._userId;
+    }
+    /**
+     * Get the channel ID for this channel.
+     * Fixed at open time — cannot be changed.
+     */
+    get channelId() {
+        return this._channelId;
+    }
+    get isReadOnly() {
+        return this._role === 'viewer';
+    }
+    // ===========================================================================
+    // Channel History Access
+    // ===========================================================================
+    /**
+     * Get interactions for this channel.
+     */
+    getInteractions() {
+        return this._channel?.interactions ?? [];
+    }
+    // ===========================================================================
+    // Channel Lifecycle
+    // ===========================================================================
+    /**
+     * Close this channel and clean up resources.
+     * Stops real-time subscription and unregisters from client.
+     */
+    close() {
+        this._closed = true;
+        this.subscriptionManager.destroy();
+        this.onCloseCallback(this._id);
+        // Clean up pending object collectors
+        this._objectResolvers.clear();
+        this._objectBuffer.clear();
+        this._pendingMutations.clear();
+        this.removeAllListeners();
+    }
+    // ===========================================================================
+    // Undo / Redo (Server-managed checkpoints)
+    // ===========================================================================
+    /**
+     * Create a checkpoint (seal current batch of changes).
+     * @returns The checkpoint ID
+     */
+    async checkpoint(label = 'Change') {
+        const result = await this.graphqlClient.checkpoint(this._id, label, this._channelId);
+        return result.checkpointId;
+    }
+    /**
+     * Check if undo is available.
+     */
+    async canUndo() {
+        const status = await this.graphqlClient.checkpointStatus(this._id, this._channelId);
+        return status.canUndo;
+    }
+    /**
+     * Check if redo is available.
+     */
+    async canRedo() {
+        const status = await this.graphqlClient.checkpointStatus(this._id, this._channelId);
+        return status.canRedo;
+    }
+    /**
+     * Undo the most recent batch of changes.
+     * Reverses your most recent batch (sealed or open).
+     * Conflicting patches (modified by others) are silently skipped.
+     * @returns true if undo was performed
+     */
+    async undo() {
+        const result = await this.graphqlClient.undo(this._id, this._channelId);
+        // Server broadcasts space_changed, which triggers a reset event
+        return result.success;
+    }
+    /**
+     * Redo a previously undone batch of changes.
+     * @returns true if redo was performed
+     */
+    async redo() {
+        const result = await this.graphqlClient.redo(this._id, this._channelId);
+        // Server broadcasts space_changed, which triggers a reset event
+        return result.success;
+    }
+    /**
+     * Clear checkpoint history for this channel.
+     */
+    async clearHistory() {
+        await this.graphqlClient.clearCheckpointHistory(this._id, this._channelId);
+    }
+    // ===========================================================================
+    // Object Operations
+    // ===========================================================================
+    /**
+     * Get an object's data by ID.
+     * Fetches from the server on each call.
+     */
+    async getObject(objectId) {
+        return this.graphqlClient.getObject(this._id, objectId);
+    }
+    /**
+     * Get an object's stat (audit information).
+     * Returns modification timestamp and author, or undefined if object not found.
+     */
+    stat(objectId) {
+        return this._objectStats.get(objectId);
+    }
+    /**
+     * Find objects using structured filters and/or natural language.
+     *
+     * `where` provides exact-match filtering — values must match literally (no placeholders or operators).
+     * `prompt` enables AI-powered semantic queries. When both are provided, `where` and `objectIds`
+     * constrain the data set before the AI sees it.
+     *
+     * @param options.where - Exact-match field filter (e.g. `{ type: 'article' }`). Constrains which objects the AI can see when combined with `prompt`.
+     * @param options.prompt - Natural language query. Triggers AI evaluation (uses credits).
+     * @param options.limit - Maximum number of results to return (applies to structured filtering only; the AI controls its own result size).
+     * @param options.objectIds - Scope search to specific object IDs. Constrains the candidate set in both structured and AI queries.
+     * @param options.order - Sort order by modifiedAt: `'asc'` or `'desc'` (default: `'desc'`). Only applies to structured filtering (no `prompt`).
+     * @param options.ephemeral - If true, the query won't be recorded in interaction history.
+     * @returns The matching objects and a descriptive message.
+     */
+    async findObjects(options) {
+        return this.graphqlClient.findObjects(this._id, options, this._channelId);
+    }
+    /**
+     * Get all object IDs (sync, from local cache).
+     * The list is loaded on open and kept current via SSE events.
+     * @param options.limit - Maximum number of IDs to return
+     * @param options.order - Sort order by modifiedAt ('asc' or 'desc', default: 'desc')
+     */
+    getObjectIds(options) {
+        let ids = this._objectIds;
+        if (options?.order === 'asc') {
+            ids = [...ids].reverse();
+        }
+        if (options?.limit !== undefined) {
+            ids = ids.slice(0, options.limit);
+        }
+        return ids;
+    }
+    /**
+     * Create a new object with optional AI generation.
+     * @param options.data - Object data fields (any key-value pairs). Optionally include `id` to use a custom ID. Use {{placeholder}} for AI-generated content. Fields prefixed with _ are hidden from AI.
+     * @param options.ephemeral - If true, the operation won't be recorded in interaction history.
+     * @returns The created object (with AI-filled content) and message
+     */
+    async createObject(options) {
+        const { data, ephemeral } = options;
+        // Use data.id if provided (string), otherwise generate
+        const objectId = typeof data.id === 'string' ? data.id : generateEntityId();
+        // Validate ID format: alphanumeric, hyphens, underscores only
+        if (!/^[a-zA-Z0-9_-]+$/.test(objectId)) {
+            throw new Error(`Invalid object ID "${objectId}". IDs must contain only alphanumeric characters, hyphens, and underscores.`);
+        }
+        const dataWithId = { ...data, id: objectId };
+        // Emit optimistic event and track for dedup
+        this._pendingMutations.set(objectId, dataWithId);
+        this.emit('objectCreated', { objectId, object: dataWithId, source: 'local_user' });
+        try {
+            // Await mutation — server processes AI placeholders before responding.
+            // SSE events arrive during the await and are buffered via _deliverObject.
+            const { message } = await this.graphqlClient.createObject(this.id, dataWithId, this._channelId, ephemeral);
+            // Collect resolved object from buffer (or wait if not yet arrived)
+            const object = await this._collectObject(objectId);
+            return { object, message };
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to create object:', error);
+            this._pendingMutations.delete(objectId);
+            this._cancelCollector(objectId);
+            // Emit reset so UI can recover from the optimistic event
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            this.emit('reset', { source: 'system' });
+            throw error;
+        }
+    }
+    /**
+     * Update an existing object.
+     * @param objectId - The ID of the object to update
+     * @param options.data - Fields to add or update. Pass null or undefined to delete a field. Use {{placeholder}} for AI-generated content. Fields prefixed with _ are hidden from AI.
+     * @param options.prompt - AI prompt for content editing (optional).
+     * @param options.ephemeral - If true, the operation won't be recorded in interaction history.
+     * @returns The updated object (with AI-filled content) and message
+     */
+    async updateObject(objectId, options) {
+        const { data, ephemeral } = options;
+        // id is immutable after creation (but null/undefined means delete attempt, which we also reject)
+        if (data?.id !== undefined && data.id !== null) {
+            throw new Error('Cannot change id in updateObject. The id field is immutable after creation.');
+        }
+        if (data && ('id' in data)) {
+            throw new Error('Cannot delete id field. The id field is immutable after creation.');
+        }
+        // Normalize undefined to null (for JSON serialization) and build server data
+        let serverData;
+        if (data) {
+            serverData = {};
+            for (const [key, value] of Object.entries(data)) {
+                // Convert undefined to null for wire protocol
+                serverData[key] = value === undefined ? null : value;
+            }
+        }
+        // Emit optimistic event if we have data changes
+        if (data) {
+            // Build optimistic object (best effort — we may not have the current state)
+            const optimistic = { id: objectId, ...data };
+            this._pendingMutations.set(objectId, optimistic);
+            this.emit('objectUpdated', { objectId, object: optimistic, source: 'local_user' });
+        }
+        try {
+            const { message } = await this.graphqlClient.updateObject(this.id, objectId, this._channelId, serverData, options.prompt, ephemeral);
+            const object = await this._collectObject(objectId);
+            return { object, message };
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to update object:', error);
+            this._pendingMutations.delete(objectId);
+            this._cancelCollector(objectId);
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            this.emit('reset', { source: 'system' });
+            throw error;
+        }
+    }
+    /**
+     * Delete objects by IDs.
+     * Other objects that reference deleted objects via data fields will retain stale ref values.
+     */
+    async deleteObjects(objectIds) {
+        if (objectIds.length === 0)
+            return;
+        // Track for dedup and emit optimistic events
+        for (const objectId of objectIds) {
+            this._pendingMutations.set(objectId, null);
+            this.emit('objectDeleted', { objectId, source: 'local_user' });
+        }
+        try {
+            await this.graphqlClient.deleteObjects(this.id, objectIds, this._channelId);
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to delete objects:', error);
+            for (const objectId of objectIds) {
+                this._pendingMutations.delete(objectId);
+            }
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            this.emit('reset', { source: 'system' });
+            throw error;
+        }
+    }
+    // ===========================================================================
+    // Collection Schema Operations
+    // ===========================================================================
+    /**
+     * Get the current schema for this space.
+     * Returns a map of collection names to their definitions.
+     */
+    getSchema() {
+        return this._schema;
+    }
+    /**
+     * Create a new collection schema.
+     * @param name - Collection name (must start with a letter, alphanumeric/hyphens/underscores only)
+     * @param fields - Field definitions for the collection
+     * @returns The created CollectionDef
+     */
+    async createCollection(name, fields) {
+        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 })) };
+        this._schema[name] = optimisticDef;
+        try {
+            return await this.graphqlClient.createCollection(this._id, name, fields, this._channelId);
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to create collection:', error);
+            delete this._schema[name];
+            throw error;
+        }
+    }
+    /**
+     * Alter an existing collection schema, replacing its field definitions.
+     * @param name - Name of the collection to alter
+     * @param fields - New field definitions (replaces all existing fields)
+     * @returns The updated CollectionDef
+     */
+    async alterCollection(name, fields) {
+        if (!this._schema[name]) {
+            throw new Error(`Collection "${name}" not found`);
+        }
+        const previous = this._schema[name];
+        // Optimistic local update
+        this._schema[name] = { fields: fields.map(f => ({ name: f.name, type: f.type })) };
+        try {
+            return await this.graphqlClient.alterCollection(this._id, name, fields, this._channelId);
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to alter collection:', error);
+            this._schema[name] = previous;
+            throw error;
+        }
+    }
+    /**
+     * Drop a collection schema.
+     * @param name - Name of the collection to drop
+     */
+    async dropCollection(name) {
+        if (!this._schema[name]) {
+            throw new Error(`Collection "${name}" not found`);
+        }
+        const previous = this._schema[name];
+        // Optimistic local update
+        delete this._schema[name];
+        try {
+            await this.graphqlClient.dropCollection(this._id, name, this._channelId);
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to drop collection:', error);
+            this._schema[name] = previous;
+            throw error;
+        }
+    }
+    // ===========================================================================
+    // System Instructions
+    // ===========================================================================
+    /**
+     * Get the system instruction for this channel.
+     * Returns undefined if no system instruction is set.
+     */
+    getSystemInstruction() {
+        return this._channel?.systemInstruction;
+    }
+    /**
+     * Set the system instruction for this channel.
+     * Pass null to clear the instruction.
+     */
+    async setSystemInstruction(instruction) {
+        // Optimistic local update
+        if (!this._channel) {
+            this._channel = {
+                createdAt: Date.now(),
+                createdBy: this._userId,
+                interactions: [],
+            };
+        }
+        const previous = this._channel;
+        if (instruction === null) {
+            const { systemInstruction: _, ...rest } = this._channel;
+            this._channel = rest;
+        }
+        else {
+            this._channel = { ...this._channel, systemInstruction: instruction };
+        }
+        // Emit event
+        this.emit('channelUpdated', {
+            channelId: this._channelId,
+            source: 'local_user',
+        });
+        // Call server
+        try {
+            await this.graphqlClient.setSystemInstruction(this.id, this._channelId, instruction);
+        }
+        catch (error) {
+            this.logger.error('[RoolChannel] Failed to set system instruction:', error);
+            this._channel = previous;
+            throw error;
+        }
+    }
+    // ===========================================================================
+    // Metadata Operations
+    // ===========================================================================
+    /**
+     * Set a space-level metadata value.
+     * Metadata is stored in meta and hidden from AI operations.
+     */
+    setMetadata(key, value) {
+        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)
+            .catch((error) => {
+            this.logger.error('[RoolChannel] Failed to set meta:', error);
+        });
+    }
+    /**
+     * Get a space-level metadata value.
+     */
+    getMetadata(key) {
+        return this._meta[key];
+    }
+    /**
+     * Get all space-level metadata.
+     */
+    getAllMetadata() {
+        return this._meta;
+    }
+    // ===========================================================================
+    // AI Operations
+    // ===========================================================================
+    /**
+     * 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) {
+        // Upload attachments via media endpoint, then send URLs to the server
+        const { attachments, ...rest } = options ?? {};
+        let attachmentUrls;
+        if (attachments?.length) {
+            attachmentUrls = await Promise.all(attachments.map(file => this.mediaClient.upload(this._id, file)));
+        }
+        const result = await this.graphqlClient.prompt(this._id, prompt, this._channelId, { ...rest, attachmentUrls });
+        // Collect modified objects — they arrive via SSE events during/after the mutation.
+        // Try collecting from buffer first, then fetch any missing from server.
+        const objects = [];
+        const missing = [];
+        for (const id of result.modifiedObjectIds) {
+            const buffered = this._objectBuffer.get(id);
+            if (buffered) {
+                this._objectBuffer.delete(id);
+                objects.push(buffered);
+            }
+            else {
+                missing.push(id);
+            }
+        }
+        // Fetch any objects not yet received via SSE
+        if (missing.length > 0) {
+            const fetched = await Promise.all(missing.map(id => this.graphqlClient.getObject(this._id, id)));
+            for (const obj of fetched) {
+                if (obj)
+                    objects.push(obj);
+            }
+        }
+        return {
+            message: result.message,
+            objects,
+        };
+    }
+    // ===========================================================================
+    // Channel Admin
+    // ===========================================================================
+    /**
+     * Rename this channel.
+     */
+    async rename(newName) {
+        await this.graphqlClient.renameChannel(this._id, this._channelId, newName);
+    }
+    // ===========================================================================
+    // Media Operations
+    // ===========================================================================
+    /**
+     * List all media files for this space.
+     */
+    async listMedia() {
+        return this.mediaClient.list(this._id);
+    }
+    /**
+     * Upload a file to this space. Returns the URL.
+     */
+    async uploadMedia(file) {
+        return this.mediaClient.upload(this._id, file);
+    }
+    /**
+     * Fetch any URL, returning headers and a blob() method (like fetch Response).
+     * Adds auth headers for backend media URLs, fetches external URLs via server proxy if CORS blocks.
+     */
+    async fetchMedia(url) {
+        return this.mediaClient.fetch(this._id, url);
+    }
+    /**
+     * Delete a media file by URL.
+     */
+    async deleteMedia(url) {
+        return this.mediaClient.delete(this._id, url);
+    }
+    // ===========================================================================
+    // Object Collection (internal)
+    // ===========================================================================
+    /**
+     * Register a collector that resolves when the object arrives via SSE.
+     * If the object is already in the buffer (arrived before collector), resolves immediately.
+     * @internal
+     */
+    _collectObject(objectId) {
+        return new Promise((resolve, reject) => {
+            // Check buffer first — SSE event may have arrived before the HTTP response
+            const buffered = this._objectBuffer.get(objectId);
+            if (buffered) {
+                this._objectBuffer.delete(objectId);
+                resolve(buffered);
+                return;
+            }
+            const timer = setTimeout(() => {
+                this._objectResolvers.delete(objectId);
+                // Fallback: try to fetch from server
+                this.graphqlClient.getObject(this._id, objectId).then(obj => {
+                    if (obj) {
+                        resolve(obj);
+                    }
+                    else {
+                        reject(new Error(`Timeout waiting for object ${objectId} from SSE`));
+                    }
+                }).catch(reject);
+            }, OBJECT_COLLECT_TIMEOUT);
+            this._objectResolvers.set(objectId, (obj) => {
+                clearTimeout(timer);
+                resolve(obj);
+            });
+        });
+    }
+    /**
+     * Cancel a pending object collector (e.g., on mutation error).
+     * @internal
+     */
+    _cancelCollector(objectId) {
+        this._objectResolvers.delete(objectId);
+        this._objectBuffer.delete(objectId);
+    }
+    /**
+     * Deliver an object to a pending collector, or buffer it for later collection.
+     * @internal
+     */
+    _deliverObject(objectId, object) {
+        const resolver = this._objectResolvers.get(objectId);
+        if (resolver) {
+            resolver(object);
+            this._objectResolvers.delete(objectId);
+        }
+        else {
+            // Buffer for prompt() or late collectors
+            this._objectBuffer.set(objectId, object);
+        }
+    }
+    // ===========================================================================
+    // Event Handlers (internal - handles space subscription events)
+    // ===========================================================================
+    /**
+     * Handle a channel event from the subscription.
+     * @internal
+     */
+    handleChannelEvent(event) {
+        // Ignore events after close - the channel is being torn down
+        if (this._closed)
+            return;
+        const changeSource = event.source === 'agent' ? 'remote_agent' : 'remote_user';
+        switch (event.type) {
+            case 'object_created':
+                if (event.objectId && event.object) {
+                    if (event.objectStat)
+                        this._objectStats.set(event.objectId, event.objectStat);
+                    this._handleObjectCreated(event.objectId, event.object, changeSource);
+                }
+                break;
+            case 'object_updated':
+                if (event.objectId && event.object) {
+                    if (event.objectStat)
+                        this._objectStats.set(event.objectId, event.objectStat);
+                    this._handleObjectUpdated(event.objectId, event.object, changeSource);
+                }
+                break;
+            case 'object_deleted':
+                if (event.objectId) {
+                    this._objectStats.delete(event.objectId);
+                    this._handleObjectDeleted(event.objectId, changeSource);
+                }
+                break;
+            case 'schema_updated':
+                if (event.schema) {
+                    this._schema = event.schema;
+                }
+                break;
+            case 'metadata_updated':
+                if (event.metadata) {
+                    this._meta = event.metadata;
+                    this.emit('metadataUpdated', { metadata: this._meta, source: changeSource });
+                }
+                break;
+            case 'channel_updated':
+                // Only update if it's our channel
+                if (event.channelId === this._channelId && event.channel) {
+                    this._channel = event.channel;
+                    this.emit('channelUpdated', { channelId: event.channelId, source: changeSource });
+                }
+                break;
+            case 'space_changed':
+                // Full reload needed (undo/redo, bulk operations)
+                void this.graphqlClient.openChannel(this._id, this._channelId).then((result) => {
+                    if (this._closed)
+                        return;
+                    this._meta = result.meta;
+                    this._schema = result.schema;
+                    this._channel = result.channel;
+                    this._objectIds = result.objectIds;
+                    this._objectStats = new Map(Object.entries(result.objectStats));
+                    this.emit('reset', { source: changeSource });
+                });
+                break;
+        }
+    }
+    /**
+     * Handle an object_created SSE event.
+     * Deduplicates against optimistic local creates.
+     * @internal
+     */
+    _handleObjectCreated(objectId, object, source) {
+        // Deliver to any pending collector (for mutation return values)
+        this._deliverObject(objectId, object);
+        // Maintain local ID list — prepend (most recently modified first)
+        this._objectIds = [objectId, ...this._objectIds.filter(id => id !== objectId)];
+        const pending = this._pendingMutations.get(objectId);
+        if (pending !== undefined) {
+            // This is our own mutation echoed back
+            this._pendingMutations.delete(objectId);
+            if (pending !== null) {
+                // It was a create — already emitted objectCreated optimistically.
+                // Emit objectUpdated only if AI resolved placeholders (data changed).
+                if (JSON.stringify(pending) !== JSON.stringify(object)) {
+                    this.emit('objectUpdated', { objectId, object, source });
+                }
+            }
+        }
+        else {
+            // Remote event — emit normally
+            this.emit('objectCreated', { objectId, object, source });
+        }
+    }
+    /**
+     * Handle an object_updated SSE event.
+     * Deduplicates against optimistic local updates.
+     * @internal
+     */
+    _handleObjectUpdated(objectId, object, source) {
+        // Deliver to any pending collector
+        this._deliverObject(objectId, object);
+        // Maintain local ID list — move to front (most recently modified)
+        this._objectIds = [objectId, ...this._objectIds.filter(id => id !== objectId)];
+        const pending = this._pendingMutations.get(objectId);
+        if (pending !== undefined) {
+            // This is our own mutation echoed back
+            this._pendingMutations.delete(objectId);
+            if (pending !== null) {
+                // Already emitted objectUpdated optimistically.
+                // Emit again only if data changed (AI resolved placeholders).
+                if (JSON.stringify(pending) !== JSON.stringify(object)) {
+                    this.emit('objectUpdated', { objectId, object, source });
+                }
+            }
+        }
+        else {
+            // Remote event
+            this.emit('objectUpdated', { objectId, object, source });
+        }
+    }
+    /**
+     * Handle an object_deleted SSE event.
+     * Deduplicates against optimistic local deletes.
+     * @internal
+     */
+    _handleObjectDeleted(objectId, source) {
+        // Remove from local ID list
+        this._objectIds = this._objectIds.filter(id => id !== objectId);
+        const pending = this._pendingMutations.get(objectId);
+        if (pending !== undefined) {
+            // This is our own delete echoed back — already emitted
+            this._pendingMutations.delete(objectId);
+        }
+        else {
+            // Remote event
+            this.emit('objectDeleted', { objectId, source });
+        }
+    }
+}
+//# sourceMappingURL=channel.js.map