@xenosystem/agent-interface-ui 0.1.36 → 0.1.37

package/dist/components/agent/conversationCollaborationController.js

@@ -1,597 +0,0 @@
-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