@xenosystem/agent-interface-ui 0.1.25 → 0.1.26

package/dist/components/agent/conversationCollaborationController.js

@@ -0,0 +1,597 @@
+import { CollaborationAppendJournalError, prepareCollaborationAppend, recoverCollaborationAppend, settleCollaborationAppend } from './conversationCollaborationAppendJournal.js';
+const KEY = 'xeno.agent.live-collaboration.v1';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const TOKEN = /^[a-f0-9]{64}$/;
+export class ConversationCollaborationController {
+    request;
+    storage;
+    state = { status: 'idle', access: null, preview: null, events: [], participants: [], transientShare: null, pendingAppend: null, error: null };
+    listeners = new Set();
+    generation = 0;
+    pendingToken = null;
+    previewSequence = 0;
+    catchupFlight = null;
+    registerFlight = null;
+    acceptFlight = null;
+    appendFlights = new Map();
+    ownerDesired = new Map();
+    ownerAttempts = new Map();
+    ownerAcknowledged = new Map();
+    ownerDrain = null;
+    mutationFlights = new Map();
+    stopLiveRead = null;
+    storageWarning = null;
+    historyCaughtUp = false;
+    constructor(request, storage) {
+        this.request = request;
+        this.storage = storage;
+    }
+    snapshot = () => this.state;
+    subscribe = (listener) => { this.listeners.add(listener); return () => this.listeners.delete(listener); };
+    publish(patch) { this.state = { ...this.state, ...patch, ...(patch.error === null && this.storageWarning ? { error: this.storageWarning } : {}) }; for (const listener of this.listeners)
+        listener(this.state); }
+    unavailable() { if (this.request)
+        return false; this.publish({ status: 'unavailable', error: 'Live collaboration is unavailable on this account host.' }); return true; }
+    load(localConversationId) {
+        this.stopLiveRead?.();
+        this.historyCaughtUp = false;
+        const generation = ++this.generation;
+        this.pendingToken = null;
+        this.catchupFlight = null;
+        this.registerFlight = null;
+        this.acceptFlight = null;
+        this.appendFlights.clear();
+        this.ownerDesired.clear();
+        this.ownerAttempts.clear();
+        this.ownerAcknowledged.clear();
+        this.ownerDrain = null;
+        this.mutationFlights.clear();
+        const stored = readCollaborationAccess(this.storage, localConversationId);
+        // Only identity is persisted, not the event projection. A saved cursor is
+        // not a snapshot: replay authorized durable events before advancing it.
+        const access = stored ? { ...stored, cursor: 0 } : null;
+        if (generation !== this.generation)
+            return;
+        this.publish({ access, status: access ? 'ready' : 'idle', preview: null, events: [], participants: [], transientShare: null, pendingAppend: null, error: null });
+    }
+    startLive(intervalMs = 1000) {
+        this.stopLiveRead?.();
+        const generation = this.generation;
+        let stopped = false, timer;
+        const stop = () => {
+            stopped = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (this.stopLiveRead === stop)
+                this.stopLiveRead = null;
+        };
+        this.stopLiveRead = stop;
+        const tick = async () => {
+            if (stopped || generation !== this.generation || !this.state.access)
+                return;
+            await this.catchUp();
+            if (!stopped && generation === this.generation && this.state.status === 'ready' && this.ownerDesired.size)
+                await this.flushOwner();
+            if (stopped || generation !== this.generation || ['revoked', 'unavailable'].includes(this.state.status))
+                return;
+            // Schedule after settlement, never an overlapping interval. Offline reads
+            // retry without user mutation; every read rechecks server authorization.
+            timer = setTimeout(() => { void tick(); }, Math.max(100, intervalMs) * (this.state.status === 'offline' ? 5 : 1));
+        };
+        void tick();
+        return stop;
+    }
+    persist(access) {
+        if (!this.storage)
+            return;
+        let entries = [];
+        try {
+            const raw = this.storage.getItem(KEY);
+            const parsed = raw ? JSON.parse(raw) : [];
+            if (Array.isArray(parsed))
+                entries = parsed;
+        }
+        catch { }
+        const retained = entries.filter(value => {
+            if (!value || typeof value !== 'object')
+                return false;
+            const item = value;
+            return access.kind === 'owner' ? !(item.kind === 'owner' && item.localConversationId === access.localConversationId) : !(item.kind === 'participant' && item.conversationId === access.conversationId);
+        });
+        try {
+            this.storage.setItem(KEY, JSON.stringify([...retained, access].slice(-100)));
+            this.storageWarning = null;
+        }
+        catch {
+            this.storageWarning = 'Collaboration is connected, but this device could not save its resume identity. Keep the conversation open until local storage is available.';
+        }
+    }
+    async registerOwner(localConversationId, title, modelId) {
+        if (this.registerFlight)
+            return this.registerFlight;
+        if (this.unavailable())
+            return false;
+        const scope = ++this.generation;
+        const flight = (async () => {
+            this.publish({ status: 'loading', error: null });
+            const result = await this.safe({ action: 'collaboration-register', collaborationLocalConversationId: localConversationId, collaborationTitle: title, collaborationModelId: modelId });
+            if (scope !== this.generation)
+                return false;
+            const id = result.collaborationConversation?.id;
+            if (!result.success || !id || !UUID.test(id))
+                return this.failure(result);
+            const access = { kind: 'owner', localConversationId, conversationId: id, cursor: 0 };
+            this.persist(access);
+            this.publish({ status: 'ready', access, error: null });
+            return true;
+        })().finally(() => { if (this.registerFlight === flight)
+            this.registerFlight = null; });
+        this.registerFlight = flight;
+        return flight;
+    }
+    async preview(linkOrToken) {
+        if (this.unavailable())
+            return false;
+        const token = extractToken(linkOrToken);
+        if (!token) {
+            this.publish({ status: 'failed', error: 'Enter a valid live collaboration link.' });
+            return false;
+        }
+        const scope = this.generation, sequence = ++this.previewSequence;
+        this.pendingToken = token;
+        this.publish({ status: 'loading', preview: null, error: null });
+        const result = await this.safe({ action: 'collaboration-preview', collaborationToken: token });
+        if (scope !== this.generation || sequence !== this.previewSequence || this.pendingToken !== token)
+            return false;
+        const value = result.collaborationConversation;
+        if (!result.success || !value?.id || !value.role) {
+            this.pendingToken = null;
+            return this.failure(result);
+        }
+        this.publish({ status: 'ready', preview: { conversationId: value.id, title: value.title, role: value.role, ownerName: value.owner?.name, messages: value.messages || [] }, error: null });
+        return true;
+    }
+    async accept() {
+        if (this.acceptFlight)
+            return this.acceptFlight;
+        if (this.unavailable())
+            return null;
+        const token = this.pendingToken;
+        if (!token) {
+            this.publish({ status: 'failed', error: 'Preview a live collaboration link before joining.' });
+            return null;
+        }
+        const scope = ++this.generation;
+        const flight = (async () => {
+            this.publish({ status: 'loading', error: null });
+            const result = await this.safe({ action: 'collaboration-accept', collaborationToken: token });
+            if (scope !== this.generation)
+                return null;
+            this.pendingToken = null;
+            const conversation = result.collaborationConversation, participant = result.collaborationParticipant;
+            if (!result.success || !conversation?.id || !participant?.role) {
+                this.publish({ preview: null });
+                this.failure(result);
+                return null;
+            }
+            const access = { kind: 'participant', conversationId: conversation.id, role: participant.role, cursor: 0 };
+            const preview = conversation.messages ? { conversationId: conversation.id, title: conversation.title, role: participant.role, messages: conversation.messages } : this.state.preview;
+            this.persist(access);
+            this.load(conversation.id);
+            this.publish({ status: 'ready', access, preview, error: null });
+            return conversation.id;
+        })().finally(() => { if (this.acceptFlight === flight)
+            this.acceptFlight = null; });
+        this.acceptFlight = flight;
+        return flight;
+    }
+    async createShare(role, expiresInDays, visibility = 'public') {
+        const access = this.state.access;
+        if (this.unavailable() || access?.kind !== 'owner') {
+            this.publish({ status: 'failed', error: 'Register this Agent conversation before creating a live share.' });
+            return null;
+        }
+        const scope = this.generation;
+        return this.singleflight(`share:${access.conversationId}`, JSON.stringify({ role, expiresInDays, visibility }), async () => {
+            this.publish({ status: 'loading', transientShare: null, error: null });
+            const result = await this.safe({ action: 'collaboration-create-share', collaborationConversationId: access.conversationId, collaborationRole: role, collaborationExpiresInDays: expiresInDays, collaborationVisibility: visibility });
+            if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'owner')
+                return;
+            if (!result.success || !result.collaborationShare) {
+                this.failure(result);
+                return;
+            }
+            this.publish({ status: 'ready', transientShare: result.collaborationShare, error: null });
+        }).then(() => this.state.transientShare);
+    }
+    clearTransientShare() { this.publish({ transientShare: null }); }
+    async restorePendingAppend() {
+        const access = this.state.access;
+        if (!this.request || access?.kind !== 'participant')
+            return;
+        const scope = this.generation, status = await this.safe({ action: 'status' });
+        if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'participant')
+            return;
+        const expectedAccountId = status.status?.state === 'signed-in' ? status.status.account?.id : undefined;
+        if (!status.success || !expectedAccountId || !UUID.test(expectedAccountId)) {
+            this.failure({ ...status, error: status.error || 'Sign in before recovering a collaboration entry.' }, true);
+            return;
+        }
+        try {
+            this.publish({ pendingAppend: recoverCollaborationAppend(this.storage, expectedAccountId, access.conversationId), error: null });
+        }
+        catch (error) {
+            this.publish({ status: 'conflict', pendingAppend: null, error: error instanceof CollaborationAppendJournalError ? error.message : 'Collaboration entry recovery failed.' });
+        }
+    }
+    catchUp() {
+        if (this.catchupFlight)
+            return this.catchupFlight;
+        const access = this.state.access;
+        if (!this.request || !access)
+            return Promise.resolve();
+        const scope = this.generation;
+        this.historyCaughtUp = false;
+        const flight = (async () => {
+            let after = access.cursor, hasMore = true, pages = 0;
+            while (hasMore && pages++ < 50) {
+                const result = await this.safe({ action: 'collaboration-events', collaborationConversationId: access.conversationId, collaborationCursor: after });
+                if (scope !== this.generation)
+                    return;
+                if (!result.success || result.collaborationCursor === undefined) {
+                    this.failure(result, true);
+                    return;
+                }
+                const incoming = result.collaborationEvents || [];
+                for (const event of incoming) {
+                    if (event.sequence <= after)
+                        continue;
+                    if (event.sequence !== after + 1) {
+                        this.publish({ status: 'conflict', error: 'Collaboration history has a cursor gap. Reload before continuing.' });
+                        return;
+                    }
+                    after = event.sequence;
+                }
+                if (result.collaborationCursor !== after) {
+                    this.publish({ status: 'conflict', error: 'Collaboration history returned an inconsistent cursor.' });
+                    return;
+                }
+                const current = result.collaborationCurrentCursor;
+                if (current !== undefined && (!Number.isSafeInteger(current) || current < after || (result.collaborationHasMore === true) !== (current > after))) {
+                    this.publish({ status: 'conflict', error: 'Collaboration history returned an inconsistent head.' });
+                    return;
+                }
+                if (incoming.length === 0) {
+                    if (result.collaborationHasMore === true) {
+                        this.publish({ status: 'conflict', error: 'Collaboration cursor did not advance.' });
+                        return;
+                    }
+                    // A successful idle read revalidates access, not the entire projection.
+                    // Preserve array identity so renderers need not fold all history again.
+                    this.historyCaughtUp = true;
+                    this.publish({ status: 'ready', error: null });
+                    return;
+                }
+                const bindings = new Map();
+                for (const event of [...this.state.events, ...incoming]) {
+                    const source = event.payload.logicalMessageId;
+                    if (!source)
+                        continue;
+                    if (!event.messageId || (bindings.has(source) && bindings.get(source) !== event.messageId)) {
+                        this.publish({ status: 'conflict', error: 'Collaboration message identity changed across revisions.' });
+                        return;
+                    }
+                    bindings.set(source, event.messageId);
+                }
+                const merged = new Map(this.state.events.map(event => [event.sequence, event]));
+                if (incoming.some(event => merged.has(event.sequence) && JSON.stringify(merged.get(event.sequence)) !== JSON.stringify(event))) {
+                    this.publish({ status: 'conflict', error: 'Previously observed collaboration history changed.' });
+                    return;
+                }
+                for (const event of incoming)
+                    if (event.sequence <= after) {
+                        merged.set(event.sequence, event);
+                        const payload = event.payload;
+                        if (event.type === 'owner.message.synced' && payload.logicalMessageId && payload.revision && (payload.role === 'user' || payload.role === 'assistant')) {
+                            const known = this.ownerAcknowledged.get(payload.logicalMessageId);
+                            if (!known || known.revision < payload.revision)
+                                this.ownerAcknowledged.set(payload.logicalMessageId, { revision: payload.revision,
+                                    hash: ownerFingerprint({ eventId: '', kind: payload.role, content: payload.content, state: payload.state }) });
+                        }
+                    }
+                const nextAccess = { ...access, cursor: after };
+                hasMore = result.collaborationHasMore === true;
+                this.historyCaughtUp = !hasMore;
+                this.persist(nextAccess);
+                this.publish({ status: hasMore ? 'loading' : 'ready', access: nextAccess, events: [...merged.values()].sort((a, b) => a.sequence - b.sequence), error: null });
+            }
+        })().finally(() => { if (this.catchupFlight === flight)
+            this.catchupFlight = null; });
+        this.catchupFlight = flight;
+        return flight;
+    }
+    append(kind, content, idempotencyKey) {
+        const access = this.state.access;
+        if (['revoked', 'unavailable'].includes(this.state.status))
+            return Promise.resolve(false);
+        if (!access || access.kind !== 'participant') {
+            this.publish({ status: 'failed', error: 'Only an accepted collaborator can add an entry.' });
+            return Promise.resolve(false);
+        }
+        if (access.role === 'viewer' || (kind === 'message' && access.role !== 'contributor')) {
+            this.publish({ status: 'failed', error: `${access.role} role cannot add this entry.` });
+            return Promise.resolve(false);
+        }
+        const scope = this.generation, hash = JSON.stringify({ conversationId: access.conversationId, kind, content }), key = idempotencyKey ? `append:${idempotencyKey}` : `append-intent:${hash}`, existing = this.appendFlights.get(key);
+        if (existing) {
+            if (existing.hash !== hash) {
+                this.publish({ status: 'conflict', error: 'An in-flight collaboration operation changed payload.' });
+                return Promise.resolve(false);
+            }
+            return existing.promise;
+        }
+        const promise = (async () => {
+            this.publish({ status: 'loading', error: null });
+            const status = await this.safe({ action: 'status' });
+            if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'participant')
+                return false;
+            const expectedAccountId = status.status?.state === 'signed-in' ? status.status.account?.id : undefined;
+            if (!status.success || !expectedAccountId || !UUID.test(expectedAccountId))
+                return this.failure({ ...status, error: status.error || 'Sign in before sending a collaboration entry.' }, true);
+            let intent;
+            try {
+                intent = prepareCollaborationAppend(this.storage, { operationId: idempotencyKey, expectedAccountId, conversationId: access.conversationId, kind, content });
+            }
+            catch (error) {
+                this.publish({ status: 'conflict', error: error instanceof CollaborationAppendJournalError ? error.message : 'Collaboration entry preparation failed.' });
+                return false;
+            }
+            const result = await this.safe({ action: 'collaboration-append', expectedAccountId: intent.expectedAccountId, collaborationConversationId: intent.conversationId, collaborationKind: intent.kind, collaborationContent: intent.content, collaborationIdempotencyKey: intent.operationId });
+            if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'participant')
+                return false;
+            const acknowledged = result.success && result.collaborationEvents?.some(event => exactAppendAcknowledgement(event, intent.operationId, intent.expectedAccountId, access.role, intent.kind, intent.content)) === true;
+            try {
+                settleCollaborationAppend(this.storage, intent.operationId, acknowledged ? 'committed' : result.success || result.code === 'REQUEST_FAILED' || result.code === 'UNCERTAIN' ? 'uncertain' : 'rejected');
+            }
+            catch (error) {
+                this.publish({ status: 'conflict', error: error instanceof CollaborationAppendJournalError ? error.message : 'Collaboration entry outcome could not be saved.' });
+                return false;
+            }
+            if (!result.success) {
+                this.failure(result);
+                return false;
+            }
+            if (!acknowledged) {
+                this.publish({ status: 'conflict', error: 'The account host did not acknowledge the exact collaboration entry.' });
+                return false;
+            }
+            this.publish({ status: 'ready', pendingAppend: null, error: null });
+            await this.catchUp();
+            return true;
+        })().finally(() => { if (this.appendFlights.get(key)?.promise === promise)
+            this.appendFlights.delete(key); });
+        this.appendFlights.set(key, { hash, promise });
+        return promise;
+    }
+    ownerSync(events) {
+        if (this.state.access?.kind !== 'owner' || events.length === 0)
+            return Promise.resolve();
+        for (const event of events)
+            this.ownerDesired.set(event.logicalMessageId || event.eventId, structuredClone(event));
+        return this.flushOwner();
+    }
+    flushOwner() {
+        if (this.ownerDrain)
+            return this.ownerDrain;
+        const access = this.state.access;
+        if (!access || access.kind !== 'owner')
+            return Promise.resolve();
+        const scope = this.generation;
+        const flight = (async () => {
+            // Recover the last authoritative revision before assigning another one.
+            await this.catchUp();
+            if (scope !== this.generation || this.state.status !== 'ready' || !this.historyCaughtUp)
+                return;
+            while (this.ownerDesired.size) {
+                if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'owner')
+                    return;
+                const [key, desired] = this.ownerDesired.entries().next().value;
+                let known = this.ownerAcknowledged.get(key);
+                let attempt = this.ownerAttempts.get(key);
+                if (attempt?.logicalMessageId && known && known.revision >= attempt.revision) {
+                    if (known.revision === attempt.revision && known.hash !== ownerFingerprint(attempt)) {
+                        this.publish({ status: 'conflict', error: 'Recovered collaboration revision does not match the dispatched message.' });
+                        return;
+                    }
+                    this.ownerAttempts.delete(key);
+                    if (ownerFingerprint(desired) === ownerFingerprint(attempt)) {
+                        this.ownerDesired.delete(key);
+                        continue;
+                    }
+                    attempt = undefined;
+                }
+                if (!attempt && known?.hash === ownerFingerprint(desired)) {
+                    this.ownerDesired.delete(key);
+                    continue;
+                }
+                if (!attempt) {
+                    attempt = desired.logicalMessageId ? { ...desired, expectedRevision: known?.revision ?? 0,
+                        revision: (known?.revision ?? 0) + 1, eventId: await revisionEventId(key, (known?.revision ?? 0) + 1) } : { ...desired };
+                    if (scope !== this.generation)
+                        return;
+                    this.ownerAttempts.set(key, attempt);
+                }
+                // Unknown acknowledgement keeps this exact immutable attempt. New render
+                // frames coalesce in ownerDesired, never mutate a dispatched revision.
+                const result = await this.safe({ action: 'collaboration-owner-sync', collaborationConversationId: access.conversationId, collaborationOwnerEvent: attempt });
+                if (scope !== this.generation)
+                    return;
+                if (!result.success) {
+                    this.failure(result);
+                    return;
+                }
+                if (!result.collaborationEvents?.some(event => exactOwnerAcknowledgement(event, attempt))) {
+                    this.publish({ status: 'conflict', error: 'Provider did not acknowledge the exact collaboration message revision.' });
+                    return;
+                }
+                known = this.ownerAcknowledged.get(key);
+                if (!known || known.revision < (attempt.revision ?? 0))
+                    this.ownerAcknowledged.set(key, { hash: ownerFingerprint(attempt), revision: attempt.revision ?? 0 });
+                else if (known.revision === (attempt.revision ?? 0) && known.hash !== ownerFingerprint(attempt)) {
+                    this.publish({ status: 'conflict', error: 'Acknowledged collaboration revision conflicts with recovered history.' });
+                    return;
+                }
+                this.ownerAttempts.delete(key);
+                if (ownerFingerprint(this.ownerDesired.get(key)) === ownerFingerprint(attempt))
+                    this.ownerDesired.delete(key);
+            }
+            await this.catchUp();
+        })().finally(() => { if (this.ownerDrain === flight)
+            this.ownerDrain = null; });
+        this.ownerDrain = flight;
+        return flight;
+    }
+    async loadParticipants() {
+        const access = this.state.access;
+        if (!access || access.kind !== 'owner' || !this.request)
+            return;
+        const scope = this.generation;
+        const result = await this.safe({ action: 'collaboration-participants', collaborationConversationId: access.conversationId });
+        if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'owner')
+            return;
+        if (!result.success) {
+            this.failure(result);
+            return;
+        }
+        this.publish({ status: 'ready', participants: result.collaborationParticipants || [], error: null });
+    }
+    async revokeParticipant(userId) {
+        const access = this.state.access;
+        if (!access || access.kind !== 'owner' || !this.request)
+            return;
+        const scope = this.generation;
+        await this.singleflight(`revoke:${access.conversationId}:${userId}`, userId, async () => {
+            const result = await this.safe({ action: 'collaboration-revoke-participant', collaborationConversationId: access.conversationId, collaborationParticipantUserId: userId });
+            if (scope !== this.generation || this.state.access?.conversationId !== access.conversationId || this.state.access?.kind !== 'owner')
+                return;
+            if (!result.success) {
+                this.failure(result);
+                return;
+            }
+            await this.loadParticipants();
+            await this.catchUp();
+        });
+    }
+    singleflight(key, hash, operation) {
+        const existing = this.mutationFlights.get(key);
+        if (existing) {
+            if (existing.hash !== hash)
+                this.publish({ status: 'conflict', error: 'An in-flight collaboration operation changed payload.' });
+            return existing.promise;
+        }
+        const promise = operation().finally(() => { if (this.mutationFlights.get(key)?.promise === promise)
+            this.mutationFlights.delete(key); });
+        this.mutationFlights.set(key, { hash, promise });
+        return promise;
+    }
+    async safe(input) {
+        try {
+            return await this.request(structuredClone(input));
+        }
+        catch {
+            return { success: false, code: 'REQUEST_FAILED', error: 'Collaboration is offline. No operation was confirmed.' };
+        }
+    }
+    failure(result, accessCheck = false) {
+        const error = result.error || 'Collaboration operation failed.';
+        const status = result.code === 'CONFLICT' || result.code === 'UNCERTAIN' ? 'conflict' : accessCheck && ['REFUSED', 'SIGNED_OUT'].includes(result.code || '') ? 'revoked' : result.code === 'UNCONFIGURED' ? 'unavailable' : /offline/i.test(error) ? 'offline' : 'failed';
+        if (status === 'revoked') {
+            ++this.generation;
+            this.stopLiveRead?.();
+            this.historyCaughtUp = false;
+            this.ownerDesired.clear();
+            this.ownerAttempts.clear();
+            this.ownerAcknowledged.clear();
+        }
+        this.publish({ status, error, ...(status === 'revoked' ? { preview: null, events: [], participants: [], transientShare: null, pendingAppend: null } : {}) });
+        return false;
+    }
+}
+export function extractToken(value) {
+    const trimmed = value.trim();
+    if (TOKEN.test(trimmed))
+        return trimmed;
+    try {
+        const token = new URL(trimmed).pathname.split('/').filter(Boolean).at(-1) || '';
+        return TOKEN.test(token) ? token : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readCollaborationAccess(storage, localConversationId) {
+    try {
+        const raw = storage?.getItem(KEY), entries = raw ? JSON.parse(raw) : [];
+        if (!Array.isArray(entries))
+            return null;
+        const candidate = entries.find(value => {
+            if (!value || typeof value !== 'object')
+                return false;
+            const item = value;
+            return localConversationId
+                ? (item.kind === 'owner' && item.localConversationId === localConversationId) || (item.kind === 'participant' && item.conversationId === localConversationId)
+                : item.kind === 'participant';
+        });
+        if (!candidate || !UUID.test(String(candidate.conversationId)) || !Number.isSafeInteger(candidate.cursor) || Number(candidate.cursor) < 0)
+            return null;
+        if (candidate.kind === 'owner' && typeof candidate.localConversationId === 'string')
+            return { kind: 'owner', localConversationId: candidate.localConversationId, conversationId: String(candidate.conversationId), cursor: Number(candidate.cursor) };
+        if (candidate.kind === 'participant' && ['viewer', 'commenter', 'contributor'].includes(String(candidate.role)))
+            return { kind: 'participant', conversationId: String(candidate.conversationId), role: candidate.role, cursor: Number(candidate.cursor) };
+    }
+    catch {
+        try {
+            storage?.removeItem(KEY);
+        }
+        catch { }
+    }
+    return null;
+}
+function identity() { return globalThis.crypto?.randomUUID?.() || `collab-${Date.now()}-${Math.random().toString(36).slice(2)}`; }
+function ownerFingerprint(event) { return JSON.stringify({ kind: event.kind, content: event.content, tool: event.tool, state: event.state }); }
+function exactOwnerAcknowledgement(event, attempt) {
+    const payload = event.payload;
+    if (attempt.kind === 'tool')
+        return event.type === 'owner.tool.synced' && payload.kind === 'tool'
+            && payload.sourceEventId === attempt.eventId && payload.tool?.name === attempt.tool?.name && payload.tool?.status === attempt.tool?.status;
+    if (event.type !== 'owner.message.synced' || payload.kind !== 'message' || payload.role !== attempt.kind || payload.content !== attempt.content)
+        return false;
+    return attempt.logicalMessageId ? payload.logicalMessageId === attempt.logicalMessageId && payload.revision === attempt.revision && payload.state === attempt.state : payload.sourceEventId === attempt.eventId;
+}
+function exactAppendAcknowledgement(event, operationId, expectedAccountId, role, kind, content) {
+    return event.type === `${kind}.appended` && event.actorUserId === expectedAccountId && event.payload.sourceEventId === operationId && event.payload.kind === kind && event.payload.role === role && event.payload.content === content;
+}
+async function revisionEventId(logicalId, revision) {
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(logicalId));
+    return `message-${Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('')}:r${revision}`;
+}
+/** The event log is immutable; the visible conversation folds revisions of one message. */
+export function collaborationEntries(state) {
+    const entries = new Map();
+    for (const message of state.preview?.messages || [])
+        entries.set(message.id, { id: message.id, messageId: message.id, revision: 0, role: message.role, content: message.content });
+    for (const event of state.events) {
+        const { payload } = event;
+        if (payload.content === undefined && !payload.tool)
+            continue;
+        const id = event.messageId || event.commentId || `event:${event.sequence}`;
+        const previous = entries.get(id), revision = payload.revision ?? 0;
+        if (previous?.sequence !== undefined && (revision < previous.revision || (revision === previous.revision && event.sequence <= previous.sequence)))
+            continue;
+        entries.set(id, { id, ...(event.messageId ? { messageId: event.messageId } : {}), sequence: event.sequence, revision,
+            role: payload.role || payload.kind || event.type, content: payload.content ?? `${payload.tool.name}: ${payload.tool.status}`,
+            ...(payload.state ? { state: payload.state } : {}) });
+    }
+    return [...entries.values()];
+}
+//# sourceMappingURL=conversationCollaborationController.js.map