@bassfish/cli 0.1.0

package/dist/service.js

@@ -0,0 +1,1185 @@
+import { createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { BassfishError, activeStates, increment, prepareMutation, requireThat, reservedStates } from './domain.js';
+import { KeyedMutex } from './runtime.js';
+import { schemas, nameSchema } from './api.js';
+import { normalizeLabels, normalizeLinks, outline, prepareNote } from './note.js';
+import { NoteSearchIndex } from './storage/search.js';
+import { exportProject as writeProjectExport } from './export.js';
+import { RE2 } from 're2-wasm';
+export const defaultLimits = { offerMs: 30_000, leaseMs: 30_000, reconnectMs: 30_000, instanceMs: 20_000, queueMs: 3_600_000, retentionMs: 3_600_000, waitMs: 20_000 };
+const values = Object.values;
+const uid = () => randomUUID();
+const iso = (ms) => new Date(ms).toISOString();
+const pendingFor = (state, instanceId) => values(state.requests).filter(r => r.instanceId === instanceId && activeStates.includes(r.state));
+function toMutation(input) {
+    return input;
+}
+const threadMutationKinds = ['appendMessage', 'renameThread', 'setThreadDescription', 'archiveThread', 'activateThread', 'deleteThread', 'retractMessage', 'reinstateMessage'];
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const sortThreads = (threads) => [...threads].sort((a, b) => compare(a.createdAt, b.createdAt) || compare(a.id, b.id));
+const encodeCursor = (pair) => Buffer.from(JSON.stringify(pair)).toString('base64url');
+function decodeCursor(cursor) {
+    if (!cursor)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(Buffer.from(String(cursor), 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new BassfishError('INVALID_CURSOR', 'The cursor is invalid.');
+    }
+    requireThat(Array.isArray(value) && value.length === 2 && value.every(item => typeof item === 'string'), 'INVALID_CURSOR', 'The cursor is invalid.');
+    return value;
+}
+/** Application service: all coordination is persisted by ControlStore; all content uses ContentStore. */
+export class Bassfish {
+    control;
+    content;
+    clock;
+    searchIndex;
+    dataDir;
+    epoch = uid();
+    limits;
+    writers = new KeyedMutex();
+    restoreSecret = randomBytes(32);
+    constructor(control, content, clock, limits = {}, searchIndex, dataDir) {
+        this.control = control;
+        this.content = content;
+        this.clock = clock;
+        this.searchIndex = searchIndex;
+        this.dataDir = dataDir;
+        this.limits = { ...defaultLimits, ...limits };
+    }
+    async initialize() {
+        const now = this.clock.now();
+        this.control.update(state => {
+            for (const instance of values(state.instances))
+                instance.active = false;
+            for (const request of values(state.requests)) {
+                if (request.state === 'QUEUED' || request.state === 'READY')
+                    request.reconnectUntil = Math.min(request.queueUntil, now + this.limits.reconnectMs);
+                if (request.state === 'READY')
+                    request.state = 'QUEUED';
+                if (request.state === 'OFFERED' || request.state === 'HELD')
+                    this.finish(request, 'EXPIRED', state);
+            }
+            for (const project of values(state.projects))
+                project.recovering = true;
+        });
+        for (const project of this.control.view(s => values(s.projects))) {
+            try {
+                await this.content.ensureProject(project.id);
+                await this.recover(project.id);
+            }
+            catch { /* Preserve PROJECT_RECOVERING; metadata diagnostics must remain available. */ }
+        }
+    }
+    async open(commonDir, preferredName) {
+        if (preferredName)
+            nameSchema.parse(preferredName);
+        const project = this.control.update(state => {
+            let project = values(state.projects).find(p => p.commonDir === commonDir);
+            if (!project) {
+                project = { id: `p_${uid().replaceAll('-', '')}`, commonDir, recovering: true };
+                state.projects[project.id] = project;
+            }
+            return project;
+        });
+        await this.writers.run(project.id, async () => {
+            await this.content.ensureProject(project.id);
+            await this.recover(project.id);
+        });
+        this.sweep();
+        const handle = uid();
+        this.control.update(state => {
+            const name = preferredName ?? `Agent_${uid().slice(0, 12).replaceAll('-', '')}`;
+            let identity = values(state.identities).find(i => i.projectId === project.id && i.name.toLowerCase() === name.toLowerCase());
+            if (!identity) {
+                identity = { id: uid(), projectId: project.id, name };
+                state.identities[identity.id] = identity;
+            }
+            requireThat(!values(state.instances).some(i => i.identityId === identity.id && i.active), 'NAME_IN_USE', 'This identity has a live adapter instance.');
+            const instance = { id: uid(), projectId: project.id, identityId: identity.id, handle, epoch: this.epoch, active: true, lastSeen: this.clock.now() };
+            state.instances[instance.id] = instance;
+            this.rebind(state, instance);
+            this.promote(state);
+        });
+        return { agentHandle: handle, session: this.info(handle) };
+    }
+    actor(state, handle) {
+        const instance = values(state.instances).find(i => i.handle === handle && i.active && i.epoch === this.epoch);
+        requireThat(instance, 'SESSION_EXPIRED', 'Open a new Bassfish instance; this handle is no longer current.');
+        const identity = state.identities[instance.identityId];
+        return { projectId: instance.projectId, instanceId: instance.id, identityId: identity.id, name: identity.name };
+    }
+    ready(state, projectId) {
+        requireThat(state.projects[projectId] && !state.projects[projectId].recovering, 'PROJECT_RECOVERING', 'The project has an unresolved storage operation.');
+    }
+    creationAllowed(state, projectId) {
+        this.ready(state, projectId);
+        requireThat(!values(state.requests).some(request => request.projectId === projectId && request.resourceType === 'project' && activeStates.includes(request.state)), 'PROJECT_FLOOR_PENDING', 'A project floor is queued or active; create the resource after it finishes.');
+    }
+    finish(request, state, control) {
+        request.state = state;
+        request.finishedAt = this.clock.now();
+        request.updatedAt = request.finishedAt;
+        const task = control && values(control.tasks).find(value => value.requestId === request.id && value.status === 'working');
+        if (task) {
+            task.updatedAt = request.finishedAt;
+            task.discardAt = request.finishedAt + this.limits.retentionMs;
+            if (state === 'FAILED') {
+                task.status = 'failed';
+                task.statusMessage = 'The floor request failed.';
+                task.error = { code: -32603, message: 'The floor request failed.' };
+            }
+            else if (state !== 'COMMITTED') {
+                task.status = 'cancelled';
+                task.statusMessage = state === 'EXPIRED' ? 'The floor request expired.' : 'The floor request was cancelled.';
+            }
+        }
+    }
+    disconnectIn(state, instance, clean) {
+        instance.active = false;
+        for (const request of values(state.requests).filter(r => r.instanceId === instance.id)) {
+            if (request.state === 'QUEUED') {
+                if (clean)
+                    this.finish(request, 'CANCELLED', state);
+                else
+                    request.reconnectUntil = Math.min(request.queueUntil, this.clock.now() + this.limits.reconnectMs);
+            }
+            if (request.state === 'READY') {
+                if (clean)
+                    this.finish(request, 'CANCELLED', state);
+                else {
+                    request.state = 'QUEUED';
+                    request.updatedAt = this.clock.now();
+                    request.reconnectUntil = Math.min(request.queueUntil, this.clock.now() + this.limits.reconnectMs);
+                }
+            }
+            if (request.state === 'HELD' || request.state === 'OFFERED')
+                this.finish(request, clean ? 'RELEASED' : 'EXPIRED', state);
+        }
+    }
+    disconnect(handle, clean = true) {
+        this.control.update(state => {
+            const instance = values(state.instances).find(i => i.handle === handle && i.epoch === this.epoch);
+            if (instance)
+                this.disconnectIn(state, instance, clean);
+            this.promote(state);
+        });
+    }
+    heartbeat(handle) {
+        this.sweep();
+        this.control.update(state => { const actor = this.actor(state, handle); state.instances[actor.instanceId].lastSeen = this.clock.now(); });
+    }
+    sweep() {
+        const now = this.clock.now();
+        const wall = this.clock.wallNow();
+        const clockChanged = this.clock.discontinuity();
+        this.control.update(state => {
+            const discontinuity = clockChanged || (state.wallClockHighWaterMs > 0 && wall + 2_000 < state.wallClockHighWaterMs);
+            state.wallClockHighWaterMs = Math.max(state.wallClockHighWaterMs, wall);
+            for (const instance of values(state.instances))
+                if (instance.active && now - instance.lastSeen >= this.limits.instanceMs)
+                    this.disconnectIn(state, instance, false);
+            for (const request of values(state.requests)) {
+                if ((request.state === 'QUEUED' || request.state === 'READY') && (now >= request.queueUntil || (request.reconnectUntil !== undefined && now >= request.reconnectUntil)))
+                    this.finish(request, 'EXPIRED', state);
+                if (request.state === 'READY' && discontinuity)
+                    this.finish(request, 'EXPIRED', state);
+                if (request.state === 'OFFERED' && (discontinuity || now >= request.claimBy))
+                    this.finish(request, 'EXPIRED', state);
+                if (request.state === 'HELD' && (discontinuity || now >= request.expiresAt))
+                    this.finish(request, 'EXPIRED', state);
+                if (request.finishedAt !== undefined && now - request.finishedAt >= this.limits.retentionMs)
+                    delete state.requests[request.id];
+            }
+            for (const task of values(state.tasks))
+                if (now >= task.discardAt)
+                    delete state.tasks[task.id];
+            this.promote(state);
+        });
+    }
+    promote(state) {
+        for (const project of values(state.projects)) {
+            if (project.recovering)
+                continue;
+            const all = values(state.requests).filter(r => r.projectId === project.id);
+            const projects = all.filter(r => r.resourceType === 'project');
+            if (projects.some(r => reservedStates.includes(r.state)))
+                continue;
+            const barrier = projects.filter(r => r.state === 'QUEUED').sort((a, b) => BigInt(a.sequence) < BigInt(b.sequence) ? -1 : 1)[0];
+            if (barrier) {
+                for (const offered of all.filter(r => r.resourceType !== 'project' && r.state === 'OFFERED')) {
+                    offered.state = 'QUEUED';
+                    delete offered.offerId;
+                    delete offered.claimBy;
+                }
+                if (all.some(r => r.resourceType !== 'project' && (r.state === 'HELD' || r.state === 'COMMITTING')))
+                    continue;
+                if (state.instances[barrier.instanceId]?.active)
+                    this.makeAvailable(state, barrier);
+                continue;
+            }
+            for (const resource of values(state.resources).filter(r => r.projectId === project.id && r.type !== 'project' && r.present)) {
+                const requests = all.filter(r => r.resourceId === resource.id);
+                if (requests.some(r => reservedStates.includes(r.state)))
+                    continue;
+                const next = requests.filter(r => r.state === 'QUEUED').sort((a, b) => BigInt(a.sequence) < BigInt(b.sequence) ? -1 : 1)[0];
+                if (!next || !state.instances[next.instanceId]?.active)
+                    continue;
+                this.makeAvailable(state, next);
+            }
+        }
+    }
+    makeAvailable(state, request) {
+        request.updatedAt = this.clock.now();
+        if (request.deliveryMode === 'task') {
+            request.state = 'READY';
+            const task = values(state.tasks).find(value => value.requestId === request.id);
+            if (task) {
+                task.updatedAt = request.updatedAt;
+                task.statusMessage = 'Floor ready; poll the task to receive a 30-second offer.';
+            }
+            return;
+        }
+        request.state = 'OFFERED';
+        request.offerId = uid();
+        request.claimBy = request.updatedAt + this.limits.offerMs;
+    }
+    materializeOffer(state, request) {
+        if (request.state !== 'READY')
+            return;
+        request.state = 'OFFERED';
+        request.offerId = uid();
+        request.claimBy = this.clock.now() + this.limits.offerMs;
+        request.updatedAt = this.clock.now();
+        const task = values(state.tasks).find(value => value.requestId === request.id && value.status === 'working');
+        if (task) {
+            task.status = 'completed';
+            task.statusMessage = 'The floor offer is ready to claim.';
+            task.updatedAt = request.updatedAt;
+            task.discardAt = task.updatedAt + this.limits.retentionMs;
+            task.result = this.statusIn(state, request);
+        }
+    }
+    rebind(state, instance) {
+        for (const request of values(state.requests)) {
+            if (request.identityId === instance.identityId && (request.state === 'QUEUED' || request.state === 'READY') && request.reconnectUntil !== undefined && request.reconnectUntil > this.clock.now()) {
+                request.instanceId = instance.id;
+                delete request.reconnectUntil;
+            }
+        }
+    }
+    info(handle) {
+        this.sweep();
+        return this.control.view(state => {
+            const actor = this.actor(state, handle);
+            return { projectId: actor.projectId, identityId: actor.identityId, adapterInstanceId: actor.instanceId, name: actor.name,
+                recovering: state.projects[actor.projectId].recovering, pendingRequests: pendingFor(state, actor.instanceId).map(r => this.statusIn(state, r)),
+                pendingCommits: values(state.pending).filter(p => p.actor.identityId === actor.identityId).map(p => ({ operationId: p.id, resourceId: p.resourceId })) };
+        });
+    }
+    requestName(handle, name) {
+        nameSchema.parse(name);
+        this.sweep();
+        this.control.update(state => {
+            const actor = this.actor(state, handle);
+            requireThat(pendingFor(state, actor.instanceId).length === 0 && !values(state.pending).some(p => p.actor.instanceId === actor.instanceId), 'FLOOR_REQUEST_EXISTS', 'Finish current operations before changing identity.');
+            const target = values(state.identities).find(i => i.projectId === actor.projectId && i.name.toLowerCase() === name.toLowerCase());
+            if (target && target.id !== actor.identityId) {
+                requireThat(!values(state.instances).some(i => i.identityId === target.id && i.active), 'NAME_IN_USE', 'This identity has a live adapter instance.');
+                state.instances[actor.instanceId].identityId = target.id;
+                this.rebind(state, state.instances[actor.instanceId]);
+            }
+            else
+                state.identities[actor.identityId].name = name;
+            this.promote(state);
+        });
+        return this.info(handle);
+    }
+    statusIn(state, request) {
+        const position = values(state.requests).filter(r => r.resourceId === request.resourceId && r.state === 'QUEUED' && BigInt(r.sequence) <= BigInt(request.sequence)).length;
+        const target = request.resourceType === 'project'
+            ? { type: 'project', purpose: request.purpose }
+            : { type: request.resourceType, id: request.resourceId };
+        return { state: request.state.toLowerCase(), requestId: request.id, target,
+            ...(request.state === 'QUEUED' ? { position } : {}),
+            ...(request.state === 'OFFERED' ? { offerId: request.offerId, claimBy: iso(request.claimBy) } : {}),
+            ...(request.expiresAt !== undefined ? { expiresAt: iso(request.expiresAt) } : {}),
+            ...(request.result ? { result: request.result } : {}) };
+    }
+    ownRequest(state, handle, ticketId) {
+        const actor = this.actor(state, handle);
+        const request = state.requests[ticketId];
+        requireThat(request && request.projectId === actor.projectId && request.identityId === actor.identityId, 'NOT_FLOOR_OWNER', 'This ticket does not belong to the calling identity.');
+        return request;
+    }
+    ownTask(state, handle, taskId) {
+        const actor = this.actor(state, handle);
+        const task = state.tasks[taskId];
+        requireThat(task && task.projectId === actor.projectId && task.identityId === actor.identityId, 'TASK_NOT_FOUND', 'Task not found for this identity.');
+        return task;
+    }
+    taskView(task) {
+        return { taskId: task.id, status: task.status, ...(task.statusMessage ? { statusMessage: task.statusMessage } : {}),
+            createdAt: iso(task.createdAt), lastUpdatedAt: iso(task.updatedAt), ttlMs: Math.max(0, task.discardAt - task.createdAt), pollIntervalMs: 1_000,
+            ...(task.status === 'completed' && task.result ? { result: task.result } : {}), ...(task.status === 'failed' && task.error ? { error: task.error } : {}) };
+    }
+    getTask(handle, taskId, materialize = true) {
+        this.sweep();
+        return this.control.update(state => {
+            const task = this.ownTask(state, handle, taskId);
+            const request = state.requests[task.requestId];
+            if (materialize && request)
+                this.materializeOffer(state, request);
+            return this.taskView(task);
+        });
+    }
+    cancelTask(handle, taskId) {
+        this.sweep();
+        return this.control.update(state => {
+            const task = this.ownTask(state, handle, taskId);
+            const request = state.requests[task.requestId];
+            if (request && task.status === 'working' && ['QUEUED', 'READY', 'OFFERED'].includes(request.state))
+                this.finish(request, 'CANCELLED', state);
+            this.promote(state);
+            return this.taskView(task);
+        });
+    }
+    async waitTask(handle, taskId, updatedAfter, timeout, signal) {
+        const until = performance.now() + Math.min(timeout, this.limits.waitMs);
+        while (true) {
+            const task = this.control.view(state => this.taskView(this.ownTask(state, handle, taskId)));
+            const updated = Date.parse(String(task.lastUpdatedAt));
+            if (updated > updatedAfter || performance.now() >= until)
+                return task;
+            try {
+                await delay(Math.min(100, Math.max(1, until - performance.now())), undefined, { signal });
+            }
+            catch {
+                throw new BassfishError('CANCELLED', 'Task observation was cancelled.');
+            }
+        }
+    }
+    status(handle, ticketId) {
+        this.sweep();
+        return this.control.update(state => { const request = this.ownRequest(state, handle, ticketId); this.materializeOffer(state, request); return this.statusIn(state, request); });
+    }
+    held(state, handle, floorId, fence) {
+        requireThat(floorId && fence, 'FLOOR_REQUIRED', 'Current floor credentials are required.');
+        const actor = this.actor(state, handle);
+        const request = values(state.requests).find(r => r.floorId === floorId);
+        requireThat(request && request.projectId === actor.projectId && request.identityId === actor.identityId && request.instanceId === actor.instanceId, 'NOT_FLOOR_OWNER', 'The floor is not bound to this adapter instance.');
+        requireThat(request.fence === fence && state.resources[request.resourceId]?.fence === fence, 'STALE_FLOOR', 'The fencing token is no longer current.');
+        requireThat(request.state !== 'EXPIRED' && this.clock.now() < request.expiresAt, 'FLOOR_EXPIRED', 'The floor deadline has elapsed.');
+        requireThat(request.state !== 'COMMITTING', 'COMMIT_IN_PROGRESS', 'This floor has an accepted write in progress.');
+        requireThat(request.state === 'HELD', 'STALE_FLOOR', 'The floor has already been released or consumed.');
+        this.ready(state, actor.projectId);
+        return request;
+    }
+    async requestResourceFloor(handle, resourceTypeOrId, maybeResourceId, deliveryMode = 'ticket') {
+        this.sweep();
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            this.control.view(s => this.ready(s, actor.projectId));
+            const resourceId = maybeResourceId ?? resourceTypeOrId;
+            const requestedType = maybeResourceId === undefined ? undefined : resourceTypeOrId;
+            const actualType = await this.content.resourceType(actor.projectId, resourceId);
+            requireThat(requestedType === undefined || actualType === requestedType, 'NOT_FOUND', 'Resource type does not match this identifier.');
+            const resourceType = actualType;
+            const ticketId = this.control.update(state => {
+                this.actor(state, handle);
+                this.ready(state, actor.projectId);
+                requireThat(pendingFor(state, actor.instanceId).length === 0, 'FLOOR_REQUEST_EXISTS', 'This adapter already has a pending floor request.');
+                const resource = state.resources[resourceId] ?? { id: resourceId, projectId: actor.projectId, type: resourceType, fence: '0', queueSequence: '0', present: true };
+                requireThat(resource.projectId === actor.projectId && resource.present, 'NOT_FOUND', 'Resource not found in this project.');
+                state.resources[resourceId] = resource;
+                resource.queueSequence = increment(resource.queueSequence);
+                const now = this.clock.now();
+                const request = { id: uid(), projectId: actor.projectId, resourceId, resourceType, identityId: actor.identityId, instanceId: actor.instanceId,
+                    sequence: resource.queueSequence, state: 'QUEUED', createdAt: now, updatedAt: now, queueUntil: now + this.limits.queueMs, deliveryMode };
+                state.requests[request.id] = request;
+                if (deliveryMode === 'task')
+                    state.tasks[request.id] = { id: request.id, projectId: actor.projectId, identityId: actor.identityId, requestId: request.id,
+                        status: 'working', statusMessage: 'Waiting for the floor.', createdAt: now, updatedAt: now, discardAt: request.queueUntil };
+                this.promote(state);
+                if (deliveryMode === 'task' && request.state === 'READY') {
+                    this.materializeOffer(state, request);
+                    delete state.tasks[request.id];
+                    request.deliveryMode = 'ticket';
+                }
+                return request.id;
+            });
+            return this.status(handle, ticketId);
+        });
+    }
+    async requestProjectFloor(handle, purpose, deliveryMode = 'ticket') {
+        this.sweep();
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            const ticketId = this.control.update(state => {
+                this.actor(state, handle);
+                this.ready(state, actor.projectId);
+                requireThat(pendingFor(state, actor.instanceId).length === 0, 'FLOOR_REQUEST_EXISTS', 'This adapter already has a pending floor request.');
+                const resourceId = `project:${actor.projectId}`;
+                const resource = state.resources[resourceId] ?? { id: resourceId, projectId: actor.projectId, type: 'project', fence: '0', queueSequence: '0', present: true };
+                state.resources[resourceId] = resource;
+                resource.queueSequence = increment(resource.queueSequence);
+                const now = this.clock.now();
+                const request = { id: uid(), projectId: actor.projectId, resourceId, resourceType: 'project', purpose, identityId: actor.identityId,
+                    instanceId: actor.instanceId, sequence: resource.queueSequence, state: 'QUEUED', createdAt: now, updatedAt: now, queueUntil: now + this.limits.queueMs, deliveryMode };
+                state.requests[request.id] = request;
+                if (deliveryMode === 'task')
+                    state.tasks[request.id] = { id: request.id, projectId: actor.projectId, identityId: actor.identityId, requestId: request.id,
+                        status: 'working', statusMessage: 'Waiting for the project floor.', createdAt: now, updatedAt: now, discardAt: request.queueUntil };
+                this.promote(state);
+                if (deliveryMode === 'task' && request.state === 'READY') {
+                    this.materializeOffer(state, request);
+                    delete state.tasks[request.id];
+                    request.deliveryMode = 'ticket';
+                }
+                return request.id;
+            });
+            return this.status(handle, ticketId);
+        });
+    }
+    async claimFloor(handle, offerId, limit, noteCursor) {
+        this.sweep();
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            const offer = () => this.control.view(state => {
+                this.actor(state, handle);
+                this.ready(state, actor.projectId);
+                const request = values(state.requests).find(r => r.offerId === offerId);
+                requireThat(request && request.instanceId === actor.instanceId && request.projectId === actor.projectId, 'NOT_FLOOR_OWNER', 'The offer is not bound to this instance.');
+                requireThat(request.state !== 'EXPIRED' && this.clock.now() < request.claimBy, 'OFFER_EXPIRED', 'The offer claim window has elapsed.');
+                requireThat(request.state === 'OFFERED', 'OFFER_UNAVAILABLE', 'This offer is no longer available.');
+                return request;
+            });
+            const request = offer();
+            if (request.resourceType === 'project') {
+                const commit = await this.content.head(actor.projectId);
+                this.sweep();
+                offer();
+                const floor = this.control.update(state => {
+                    const current = state.requests[request.id];
+                    const resource = state.resources[current.resourceId];
+                    resource.fence = increment(resource.fence);
+                    current.state = 'HELD';
+                    current.floorId = uid();
+                    current.fence = resource.fence;
+                    current.baseRevision = '0';
+                    current.snapshotCommit = commit;
+                    current.expiresAt = this.clock.now() + this.limits.leaseMs;
+                    return current;
+                });
+                return { requestId: floor.id, target: { type: 'project', purpose: floor.purpose },
+                    floor: { id: floor.floorId, fencingToken: floor.fence, expiresAt: iso(floor.expiresAt) }, snapshot: { commit }, serverTime: iso(this.clock.now()) };
+            }
+            const snapshot = request.resourceType === 'thread'
+                ? await this.content.snapshot(actor.projectId, request.resourceId, limit)
+                : await this.content.noteSnapshot(actor.projectId, request.resourceId, noteCursor);
+            this.sweep();
+            offer();
+            const floor = this.control.update(state => {
+                const current = state.requests[request.id];
+                const resource = state.resources[current.resourceId];
+                resource.fence = increment(resource.fence);
+                current.state = 'HELD';
+                current.floorId = uid();
+                current.fence = resource.fence;
+                current.baseRevision = snapshot.resourceType === 'thread' ? snapshot.thread.revision : snapshot.note.revision;
+                current.snapshotCommit = snapshot.commit;
+                current.expiresAt = this.clock.now() + this.limits.leaseMs;
+                return current;
+            });
+            this.control.view(s => this.held(s, handle, floor.floorId, floor.fence));
+            const page = snapshot.resourceType === 'thread'
+                ? { type: 'thread', thread: snapshot.thread, messages: snapshot.messages, truncated: snapshot.truncated }
+                : { type: 'note', note: this.noteMetadata(snapshot.note), ...snapshot.page };
+            return { requestId: floor.id, target: { type: snapshot.resourceType, id: request.resourceId },
+                floor: { id: floor.floorId, fencingToken: floor.fence, expiresAt: iso(floor.expiresAt) }, snapshot: { commit: snapshot.commit, revision: floor.baseRevision },
+                page, nextCursor: snapshot.resourceType === 'thread' ? snapshot.nextBefore : snapshot.page.nextCursor, serverTime: iso(this.clock.now()) };
+        });
+    }
+    async read(handle, floorId, fence, limit, before) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType === 'thread', 'RESOURCE_TYPE_MISMATCH', 'This floor belongs to a note.');
+        const snapshot = await this.content.snapshot(request.projectId, request.resourceId, limit, before, request.snapshotCommit);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return { target: { type: 'thread', id: request.resourceId }, snapshot: { commit: snapshot.commit, revision: request.baseRevision },
+            page: { type: 'thread', messages: snapshot.messages }, nextCursor: snapshot.nextBefore };
+    }
+    async readNote(handle, floorId, fence, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType === 'note', 'RESOURCE_TYPE_MISMATCH', 'This floor belongs to a thread.');
+        const snapshot = await this.content.noteSnapshot(request.projectId, request.resourceId, cursor, request.snapshotCommit);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return { target: { type: 'note', id: snapshot.note.id }, snapshot: { commit: snapshot.commit, revision: request.baseRevision }, page: { type: 'note', note: this.noteMetadata(snapshot.note), ...snapshot.page }, nextCursor: snapshot.page.nextCursor };
+    }
+    async readFloor(handle, floorId, fence, cursor) {
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        if (request.resourceType === 'thread')
+            return this.read(handle, floorId, fence, 20, cursor);
+        if (request.resourceType === 'note')
+            return this.readNote(handle, floorId, fence, cursor);
+        throw new BassfishError('RESOURCE_TYPE_MISMATCH', 'Project floors have operation-specific readers.');
+    }
+    async noteOutline(handle, floorId, fence) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType === 'note', 'RESOURCE_TYPE_MISMATCH', 'This floor does not belong to a note.');
+        const snapshot = await this.content.noteSnapshot(request.projectId, request.resourceId, undefined, request.snapshotCommit);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return { noteId: request.resourceId, revision: request.baseRevision, snapshotCommit: request.snapshotCommit, headings: outline(snapshot.note.body) };
+    }
+    async findNote(handle, floorId, fence, query, mode, limit) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType === 'note', 'RESOURCE_TYPE_MISMATCH', 'This floor does not belong to a note.');
+        const snapshot = await this.content.noteSnapshot(request.projectId, request.resourceId, undefined, request.snapshotCommit);
+        const body = snapshot.note.body;
+        const ranges = [];
+        if (mode === 'literal') {
+            let at = 0;
+            while (ranges.length < limit && (at = body.indexOf(query, at)) >= 0) {
+                ranges.push({ start: at, end: at + query.length });
+                at += Math.max(1, query.length);
+            }
+        }
+        else {
+            const regex = new RE2(query, 'gu');
+            let match;
+            while (ranges.length < limit && (match = regex.exec(body))) {
+                ranges.push({ start: match.index, end: match.index + match[0].length });
+                if (!match[0])
+                    regex.lastIndex++;
+            }
+        }
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return { noteId: request.resourceId, revision: request.baseRevision, snapshotCommit: request.snapshotCommit, matches: ranges.map(range => ({
+                startCharacter: range.start, endCharacter: range.end, line: body.slice(0, range.start).split('\n').length,
+                snippet: body.slice(Math.max(0, range.start - 128), Math.min(body.length, range.end + 384))
+            })) };
+    }
+    releaseFloor(handle, floorId, fence) {
+        this.sweep();
+        return this.control.update(state => {
+            const request = this.held(state, handle, floorId, fence);
+            this.finish(request, 'RELEASED', state);
+            this.promote(state);
+            return this.statusIn(state, request);
+        });
+    }
+    cancelFloorRequest(handle, ticketId) {
+        this.sweep();
+        return this.control.update(state => {
+            const actor = this.actor(state, handle);
+            const request = this.ownRequest(state, handle, ticketId);
+            requireThat(request.instanceId === actor.instanceId, 'NOT_FLOOR_OWNER', 'Rebind this queue request before cancelling it.');
+            requireThat(request.state !== 'HELD' && request.state !== 'COMMITTING', 'FLOOR_ALREADY_HELD', 'The floor has already been claimed.');
+            if (request.state === 'QUEUED' || request.state === 'READY' || request.state === 'OFFERED')
+                this.finish(request, 'CANCELLED', state);
+            this.promote(state);
+            return this.statusIn(state, request);
+        });
+    }
+    async waitForFloor(handle, ticketId, timeout, signal) {
+        requireThat(timeout <= this.limits.waitMs, 'INVALID_ARGUMENT', 'The wait exceeds the configured maximum.');
+        const until = performance.now() + timeout;
+        while (true) {
+            const status = this.status(handle, ticketId);
+            if (status.state !== 'queued' || performance.now() >= until)
+                return status;
+            try {
+                await delay(Math.min(100, Math.max(1, until - performance.now())), undefined, { signal });
+            }
+            catch {
+                try {
+                    this.cancelFloorRequest(handle, ticketId);
+                }
+                catch { /* Claim may already have won. */ }
+                throw new BassfishError('CANCELLED', 'The wait was cancelled; inspect ticket state.');
+            }
+        }
+    }
+    async createThread(handle, title, description) {
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            this.control.view(s => { this.actor(s, handle); this.creationAllowed(s, actor.projectId); });
+            const startingHead = await this.content.head(actor.projectId);
+            const thread = { id: uid(), title, description, state: 'active', revision: '1', headSequence: '0', creator: actor.identityId, createdAt: iso(this.clock.now()) };
+            const operation = { id: uid(), actor, resourceId: thread.id, resourceType: 'thread', at: thread.createdAt, thread, mutation: { kind: 'createThread' } };
+            this.control.update(state => {
+                this.actor(state, handle);
+                this.creationAllowed(state, actor.projectId);
+                state.pending[operation.id] = { id: operation.id, projectId: actor.projectId, resourceId: thread.id, resourceType: 'thread', startingHead, kind: 'createThread', actor };
+            });
+            const result = await this.persist(operation);
+            return { threadId: thread.id, title, state: thread.state, ...result };
+        });
+    }
+    noteMetadata(note) {
+        const { body, ...metadata } = note;
+        return { ...metadata, contentBytes: Buffer.byteLength(body, 'utf8') };
+    }
+    async validateLinks(projectId, links) {
+        if (!links.length)
+            return;
+        const snapshot = await this.content.projectSnapshot(projectId);
+        const ids = {
+            note: new Set(snapshot.notes.map(value => value.id)),
+            thread: new Set(snapshot.threads.map(value => value.id)),
+            message: new Set(snapshot.messages.map(value => value.id)),
+        };
+        for (const link of links)
+            requireThat(ids[link.targetType].has(link.targetId), 'LINK_TARGET_NOT_FOUND', `The ${link.targetType} link target does not exist in this project.`);
+    }
+    async createNote(handle, input) {
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            this.control.view(s => { this.actor(s, handle); this.creationAllowed(s, actor.projectId); });
+            const links = normalizeLinks(input.links.map(link => ({ targetType: link.targetType, targetId: link.targetId })));
+            await this.validateLinks(actor.projectId, links);
+            const startingHead = await this.content.head(actor.projectId);
+            const at = iso(this.clock.now());
+            const note = { id: uid(), path: input.path, title: input.title, body: input.body, labels: normalizeLabels(input.labels), kind: input.noteKind,
+                state: 'active', revision: '1', creator: actor.identityId, creatorName: actor.name, lastEditor: actor.identityId,
+                lastEditorName: actor.name, createdAt: at, updatedAt: at, links };
+            const operation = { id: uid(), actor, resourceId: note.id, resourceType: 'note', at, note, mutation: { kind: 'createNote' } };
+            this.control.update(state => {
+                this.actor(state, handle);
+                this.creationAllowed(state, actor.projectId);
+                state.pending[operation.id] = {
+                    id: operation.id, projectId: actor.projectId, resourceId: note.id, resourceType: 'note', startingHead, kind: 'createNote', actor
+                };
+            });
+            const result = await this.persist(operation);
+            return { noteId: note.id, path: note.path, title: note.title, state: note.state, ...result };
+        });
+    }
+    signRestore(payload) {
+        const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
+        return `${body}.${createHmac('sha256', this.restoreSecret).update(body).digest('base64url')}`;
+    }
+    verifyRestore(token) {
+        const [body, signature, extra] = token.split('.');
+        requireThat(body && signature && !extra, 'INVALID_PREVIEW', 'The restore preview token is invalid.');
+        const expected = createHmac('sha256', this.restoreSecret).update(body).digest();
+        const actual = Buffer.from(signature, 'base64url');
+        requireThat(actual.length === expected.length && timingSafeEqual(actual, expected), 'INVALID_PREVIEW', 'The restore preview token is invalid.');
+        try {
+            return JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+        }
+        catch {
+            throw new BassfishError('INVALID_PREVIEW', 'The restore preview token is invalid.');
+        }
+    }
+    async resourceHistory(handle, floorId, fence, offset, limit) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType !== 'project', 'RESOURCE_TYPE_MISMATCH', 'Project floors do not have one resource history.');
+        const entries = await this.content.history(request.projectId, request.resourceType, request.resourceId);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return { target: { type: request.resourceType, id: request.resourceId }, entries: entries.slice(offset, offset + limit), nextOffset: offset + limit < entries.length ? offset + limit : null };
+    }
+    async resourceAt(handle, floorId, fence, revision, limit, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType !== 'project', 'RESOURCE_TYPE_MISMATCH', 'Use a resource floor for historical reads.');
+        const commit = await this.content.commitAtRevision(request.projectId, request.resourceType, request.resourceId, revision);
+        const snapshot = request.resourceType === 'thread' ? await this.content.snapshot(request.projectId, request.resourceId, limit, undefined, commit)
+            : await this.content.noteSnapshot(request.projectId, request.resourceId, cursor, commit);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        return snapshot.resourceType === 'thread'
+            ? { target: { type: 'thread', id: request.resourceId }, revision, snapshotCommit: commit, page: { type: 'thread', thread: snapshot.thread, messages: snapshot.messages, truncated: snapshot.truncated }, nextCursor: snapshot.nextBefore }
+            : { target: { type: 'note', id: request.resourceId }, revision, snapshotCommit: commit, page: { type: 'note', note: this.noteMetadata(snapshot.note), ...snapshot.page }, nextCursor: snapshot.page.nextCursor };
+    }
+    async diffResource(handle, floorId, fence, revision) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType !== 'project', 'RESOURCE_TYPE_MISMATCH', 'Use a resource floor for diffs.');
+        const targetCommit = await this.content.commitAtRevision(request.projectId, request.resourceType, request.resourceId, revision);
+        if (request.resourceType === 'note') {
+            const [target, current] = await Promise.all([this.content.noteSnapshot(request.projectId, request.resourceId, undefined, targetCommit), this.content.noteSnapshot(request.projectId, request.resourceId)]);
+            this.sweep();
+            this.control.view(s => this.held(s, handle, floorId, fence));
+            return { target: { type: 'note', id: request.resourceId }, fromRevision: revision, toRevision: current.note.revision, fromCommit: targetCommit, toCommit: current.commit,
+                metadataChanged: JSON.stringify(this.noteMetadata(target.note)) !== JSON.stringify(this.noteMetadata(current.note)), before: target.page, after: current.page };
+        }
+        const [target, current] = await Promise.all([this.content.snapshot(request.projectId, request.resourceId, 1_000_000, undefined, targetCommit), this.content.snapshot(request.projectId, request.resourceId, 1_000_000)]);
+        this.sweep();
+        this.control.view(s => this.held(s, handle, floorId, fence));
+        const targetIds = new Set(target.messages.filter(message => !message.retracted).map(message => message.id));
+        const currentIds = new Set(current.messages.filter(message => !message.retracted).map(message => message.id));
+        return { target: { type: 'thread', id: request.resourceId }, fromRevision: revision, toRevision: current.thread.revision, fromCommit: targetCommit, toCommit: current.commit,
+            metadataChanged: JSON.stringify(target.thread) !== JSON.stringify(current.thread), messagesAdded: [...currentIds].filter(id => !targetIds.has(id)), messagesRemoved: [...targetIds].filter(id => !currentIds.has(id)) };
+    }
+    async previewRestore(handle, floorId, fence, revision) {
+        this.sweep();
+        const request = this.control.view(s => this.held(s, handle, floorId, fence));
+        requireThat(request.resourceType !== 'project', 'RESOURCE_TYPE_MISMATCH', 'Use a resource floor for this restore preview.');
+        const targetCommit = await this.content.commitAtRevision(request.projectId, request.resourceType, request.resourceId, revision);
+        const preview = await this.diffResource(handle, floorId, fence, revision);
+        const token = this.signRestore({ floorId, fence, projectId: request.projectId, resourceType: request.resourceType, resourceId: request.resourceId,
+            currentRevision: request.baseRevision, targetRevision: revision, targetCommit, expiresAt: request.expiresAt });
+        return { ...preview, previewToken: token, expiresAt: iso(request.expiresAt) };
+    }
+    async restoreRevision(handle, floorId, fence, token) {
+        this.sweep();
+        const payload = this.verifyRestore(token);
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            const request = this.control.view(s => this.held(s, handle, floorId, fence));
+            requireThat(payload.floorId === floorId && payload.fence === fence && payload.projectId === actor.projectId && payload.resourceId === request.resourceId &&
+                payload.resourceType === request.resourceType && payload.currentRevision === request.baseRevision && Number(payload.expiresAt) > this.clock.now(), 'PREVIEW_STALE', 'The restore preview no longer matches this floor.');
+            const at = iso(this.clock.now());
+            let operation;
+            if (request.resourceType === 'note') {
+                const [target, current] = await Promise.all([this.content.noteSnapshot(actor.projectId, request.resourceId, undefined, payload.targetCommit), this.content.noteSnapshot(actor.projectId, request.resourceId)]);
+                requireThat(current.note.revision === request.baseRevision, 'REVISION_CHANGED', 'The current note changed after the floor was claimed.');
+                const note = { ...target.note, revision: increment(current.note.revision), lastEditor: actor.identityId, lastEditorName: actor.name, updatedAt: at };
+                operation = { id: uid(), actor, resourceId: request.resourceId, resourceType: 'note', at, note, mutation: { kind: 'replaceNoteBody', body: note.body } };
+            }
+            else {
+                const [target, current] = await Promise.all([this.content.snapshot(actor.projectId, request.resourceId, 1_000_000, undefined, payload.targetCommit), this.content.snapshot(actor.projectId, request.resourceId, 1_000_000)]);
+                requireThat(current.thread.revision === request.baseRevision, 'REVISION_CHANGED', 'The current thread changed after the floor was claimed.');
+                const thread = { ...target.thread, revision: increment(current.thread.revision), headSequence: current.thread.headSequence };
+                const targetVisibility = new Map(target.messages.map(message => [message.id, !message.retracted]));
+                const visibilityChanges = current.messages.filter(message => (!message.retracted) !== (targetVisibility.get(message.id) ?? false)).map(message => ({ messageId: message.id, visible: targetVisibility.get(message.id) ?? false }));
+                operation = { id: uid(), actor, resourceId: request.resourceId, resourceType: 'thread', at, thread, mutation: { kind: 'restoreThreadRevision', targetRevision: payload.targetRevision }, visibilityChanges };
+            }
+            this.control.update(state => {
+                const current = this.held(state, handle, floorId, fence);
+                current.state = 'COMMITTING';
+                state.pending[operation.id] = {
+                    id: operation.id, projectId: actor.projectId, resourceId: request.resourceId, resourceType: request.resourceType, floorRequestId: request.id,
+                    startingHead: request.snapshotCommit, kind: 'restoreRevision', actor
+                };
+            });
+            return this.persist(operation);
+        });
+    }
+    projectHeld(state, handle, floorId, fence, purpose) {
+        const request = this.held(state, handle, floorId, fence);
+        requireThat(request.resourceType === 'project', 'RESOURCE_TYPE_MISMATCH', 'A project floor is required.');
+        requireThat(!purpose || request.purpose === purpose, 'PROJECT_PURPOSE_MISMATCH', 'This project floor was acquired for another purpose.');
+        return request;
+    }
+    async projectSnapshotInfo(handle, floorId, fence) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'snapshot'));
+        const snapshot = await this.content.projectSnapshot(request.projectId, request.snapshotCommit);
+        this.sweep();
+        this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'snapshot'));
+        return { snapshotCommit: snapshot.commit, threads: snapshot.threads.map(thread => ({ id: thread.id, title: thread.title, description: thread.description, state: thread.state, revision: thread.revision })),
+            notes: snapshot.notes.map(note => this.noteMetadata(note)), messageCount: snapshot.messages.length };
+    }
+    cursorOffset(token, expected) {
+        if (!token)
+            return 0;
+        const payload = this.verifyRestore(token);
+        for (const [key, value] of Object.entries(expected))
+            requireThat(payload[key] === value, 'INVALID_CURSOR', 'The cursor does not match this snapshot or query.');
+        requireThat(Number.isSafeInteger(payload.offset) && Number(payload.offset) >= 0, 'INVALID_CURSOR', 'The cursor offset is invalid.');
+        return Number(payload.offset);
+    }
+    nextCursor(offset, expected) { return offset === null ? null : this.signRestore({ ...expected, offset }); }
+    async projectSearch(handle, floorId, fence, query, states, limit, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'search'));
+        requireThat(this.searchIndex, 'SEARCH_UNAVAILABLE', 'The rebuildable search index is unavailable.');
+        const key = { kind: 'currentSearch', snapshotCommit: request.snapshotCommit, query, states: JSON.stringify(states) };
+        const offset = this.cursorOffset(cursor, key);
+        const snapshot = await this.content.projectSnapshot(request.projectId, request.snapshotCommit);
+        this.searchIndex.ensure(request.projectId, snapshot.commit, snapshot.notes);
+        const matches = this.searchIndex.search(request.projectId, query, states, limit, offset);
+        this.sweep();
+        this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'search'));
+        return { snapshotCommit: snapshot.commit, matches: matches.map(match => ({ noteId: match.noteId, path: match.path, revision: match.revision, snippet: match.snippet })), nextCursor: this.nextCursor(matches.length === limit ? offset + limit : null, key) };
+    }
+    async projectHistorySearch(handle, floorId, fence, query, noteId, states, limit, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'search'));
+        requireThat(this.searchIndex, 'SEARCH_UNAVAILABLE', 'The rebuildable search index is unavailable.');
+        const key = { kind: 'historySearch', snapshotCommit: request.snapshotCommit, query, noteId: noteId ?? null, states: JSON.stringify(states) };
+        const offset = this.cursorOffset(cursor, key);
+        const history = await this.content.historicalNotes(request.projectId, request.snapshotCommit);
+        this.searchIndex.ensureHistory(request.projectId, request.snapshotCommit, history);
+        const matches = this.searchIndex.searchHistory(request.projectId, query, states, noteId, limit, offset);
+        this.sweep();
+        this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'search'));
+        return { snapshotCommit: request.snapshotCommit, matches, nextCursor: this.nextCursor(matches.length === limit ? offset + limit : null, key) };
+    }
+    async projectHistoryList(handle, floorId, fence, limit, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'restore'));
+        const key = { kind: 'projectHistory', snapshotCommit: request.snapshotCommit };
+        const offset = this.cursorOffset(cursor, key);
+        const entries = await this.content.projectHistory(request.projectId);
+        const page = entries.filter(value => value.doltCommit).slice(offset, offset + limit);
+        this.sweep();
+        this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'restore'));
+        return { snapshotCommit: request.snapshotCommit, entries: page, nextCursor: this.nextCursor(page.length === limit ? offset + limit : null, key) };
+    }
+    async buildProjectRestore(projectId, actor, current, target) {
+        const changes = [];
+        const at = iso(this.clock.now());
+        const currentThreads = new Map(current.threads.map(value => [value.id, value]));
+        const targetThreads = new Map(target.threads.map(value => [value.id, value]));
+        const currentNotes = new Map(current.notes.map(value => [value.id, value]));
+        const targetNotes = new Map(target.notes.map(value => [value.id, value]));
+        const threadShape = (snapshot, id) => ({ thread: snapshot.threads.find(value => value.id === id) ? (() => { const { revision: _r, headSequence: _s, ...rest } = snapshot.threads.find(value => value.id === id); return rest; })() : null,
+            messages: snapshot.messages.filter(value => value.threadId === id), visibility: snapshot.visibility.filter(value => value.threadId === id).map(({ threadRevision: _r, ...rest }) => rest) });
+        const noteShape = (note) => note ? (() => { const { revision: _r, lastEditor: _e, lastEditorName: _n, updatedAt: _u, ...rest } = note; return rest; })() : null;
+        const changedThreads = new Map();
+        const changedNotes = new Map();
+        for (const id of new Set([...currentThreads.keys(), ...targetThreads.keys()])) {
+            const before = currentThreads.get(id);
+            const after = targetThreads.get(id);
+            if (JSON.stringify(threadShape(current, id)) === JSON.stringify(threadShape(target, id)))
+                continue;
+            const next = increment(await this.content.maxRevision(projectId, 'thread', id));
+            changedThreads.set(id, next);
+            changes.push({ resourceType: 'thread', resourceId: id, action: !before ? 'create' : !after ? 'delete' : 'update', beforeRevision: before?.revision ?? '0', afterRevision: next });
+        }
+        for (const id of new Set([...currentNotes.keys(), ...targetNotes.keys()])) {
+            const before = currentNotes.get(id);
+            const after = targetNotes.get(id);
+            if (JSON.stringify(noteShape(before)) === JSON.stringify(noteShape(after)))
+                continue;
+            const next = increment(await this.content.maxRevision(projectId, 'note', id));
+            changedNotes.set(id, next);
+            changes.push({ resourceType: 'note', resourceId: id, action: !before ? 'create' : !after ? 'delete' : 'update', beforeRevision: before?.revision ?? '0', afterRevision: next });
+        }
+        changes.sort((a, b) => `${a.resourceType}:${a.resourceId}`.localeCompare(`${b.resourceType}:${b.resourceId}`));
+        const threads = await Promise.all(target.threads.map(async (thread) => ({ ...thread, revision: changedThreads.get(thread.id) ?? currentThreads.get(thread.id)?.revision ?? thread.revision,
+            headSequence: await this.content.maxSequence(projectId, thread.id) })));
+        const notes = target.notes.map(note => changedNotes.has(note.id) ? { ...note, revision: changedNotes.get(note.id), lastEditor: actor.identityId, lastEditorName: actor.name, updatedAt: at }
+            : { ...note, revision: currentNotes.get(note.id)?.revision ?? note.revision });
+        const snapshot = { ...target, threads, notes };
+        const summary = {
+            threads: { create: changes.filter(c => c.resourceType === 'thread' && c.action === 'create').length, update: changes.filter(c => c.resourceType === 'thread' && c.action === 'update').length, delete: changes.filter(c => c.resourceType === 'thread' && c.action === 'delete').length },
+            notes: { create: changes.filter(c => c.resourceType === 'note' && c.action === 'create').length, update: changes.filter(c => c.resourceType === 'note' && c.action === 'update').length, delete: changes.filter(c => c.resourceType === 'note' && c.action === 'delete').length },
+            messages: { current: current.messages.length, target: target.messages.length }, links: { current: current.notes.reduce((n, v) => n + v.links.length, 0), target: target.notes.reduce((n, v) => n + v.links.length, 0) },
+            visibility: { current: current.visibility.length, target: target.visibility.length },
+        };
+        const digest = createHmac('sha256', this.restoreSecret).update(JSON.stringify({ current: current.commit, target: target.commit, changes, summary })).digest('base64url');
+        return { snapshot, changes, digest, summary };
+    }
+    async previewProjectRestore(handle, floorId, fence, targetCommit, limit, cursor) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'restore'));
+        const actor = this.control.view(s => this.actor(s, handle));
+        const [current, target] = await Promise.all([this.content.projectSnapshot(request.projectId, request.snapshotCommit), this.content.projectSnapshot(request.projectId, targetCommit)]);
+        const built = await this.buildProjectRestore(request.projectId, actor, current, target);
+        const key = { kind: 'restoreChanges', currentCommit: current.commit, targetCommit: target.commit, digest: built.digest };
+        const offset = this.cursorOffset(cursor, key);
+        const page = built.changes.slice(offset, offset + limit);
+        const previewToken = this.signRestore({ kind: 'snapshotRestore', floorId, fence, projectId: request.projectId, currentCommit: current.commit, targetCommit: target.commit, digest: built.digest, expiresAt: request.expiresAt });
+        this.sweep();
+        this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'restore'));
+        return { currentCommit: current.commit, targetCommit: target.commit, summary: built.summary, changes: page, nextCursor: this.nextCursor(page.length === limit ? offset + limit : null, key), previewToken, expiresAt: iso(request.expiresAt) };
+    }
+    async restoreProject(handle, floorId, fence, token) {
+        this.sweep();
+        const payload = this.verifyRestore(token);
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'restore'));
+            requireThat(payload.kind === 'snapshotRestore' && payload.floorId === floorId && payload.fence === fence && payload.projectId === actor.projectId && payload.currentCommit === request.snapshotCommit && Number(payload.expiresAt) > this.clock.now(), 'PREVIEW_STALE', 'The restore preview no longer matches this floor.');
+            const [current, target] = await Promise.all([this.content.projectSnapshot(actor.projectId), this.content.projectSnapshot(actor.projectId, String(payload.targetCommit))]);
+            requireThat(current.commit === request.snapshotCommit, 'PREVIEW_STALE', 'The project changed after the restore preview.');
+            const built = await this.buildProjectRestore(actor.projectId, actor, current, target);
+            requireThat(built.digest === payload.digest, 'PREVIEW_STALE', 'The restore change set changed.');
+            requireThat(built.changes.length > 0, 'NO_CHANGE', 'The target snapshot already matches visible project content.');
+            const operationId = uid();
+            const at = iso(this.clock.now());
+            const restoredThreadRevisions = new Map(built.changes.filter(change => change.resourceType === 'thread' && change.action !== 'delete').map(change => [change.resourceId, change.afterRevision]));
+            const restoredSnapshot = { ...built.snapshot, visibility: built.snapshot.visibility.map(value => restoredThreadRevisions.has(value.threadId)
+                    ? { ...value, threadRevision: restoredThreadRevisions.get(value.threadId), operationId, createdAt: at } : value) };
+            const operation = { id: operationId, actor, resourceId: request.resourceId, resourceType: 'project', at, mutation: { kind: 'restoreSnapshot', targetCommit: target.commit }, target: restoredSnapshot, current, changes: built.changes };
+            this.control.update(state => { const held = this.projectHeld(state, handle, floorId, fence, 'restore'); held.state = 'COMMITTING'; held.updatedAt = this.clock.now(); state.pending[operation.id] = { id: operation.id, projectId: actor.projectId, resourceId: request.resourceId, resourceType: 'project', floorRequestId: request.id, startingHead: current.commit, kind: 'restoreSnapshot', actor }; });
+            return this.persist(operation);
+        });
+    }
+    async exportProject(handle, floorId, fence) {
+        this.sweep();
+        const request = this.control.view(s => this.projectHeld(s, handle, floorId, fence, 'export'));
+        requireThat(this.dataDir, 'EXPORT_UNAVAILABLE', 'Export storage is unavailable.');
+        const snapshot = await this.content.projectSnapshot(request.projectId, request.snapshotCommit);
+        const result = await writeProjectExport(this.dataDir, request.projectId, snapshot);
+        this.sweep();
+        this.control.update(s => { const current = this.projectHeld(s, handle, floorId, fence, 'export'); this.finish(current, 'RELEASED', s); this.promote(s); });
+        return result;
+    }
+    async commitFloor(handle, floorId, fence, base, mutation) {
+        this.sweep();
+        const actor = this.control.view(s => this.actor(s, handle));
+        return this.writers.run(actor.projectId, async () => {
+            this.sweep();
+            const request = this.control.view(s => this.held(s, handle, floorId, fence));
+            const snapshot = request.resourceType === 'thread' ? await this.content.snapshot(actor.projectId, request.resourceId, 1) : await this.content.noteSnapshot(actor.projectId, request.resourceId);
+            const currentRevision = snapshot.resourceType === 'thread' ? snapshot.thread.revision : snapshot.note.revision;
+            requireThat(base === request.baseRevision && base === currentRevision, 'REVISION_CHANGED', 'The mutation base must match the current claimed revision.');
+            const at = iso(this.clock.now());
+            let operation;
+            if (snapshot.resourceType === 'thread') {
+                requireThat(threadMutationKinds.includes(mutation.kind), 'RESOURCE_TYPE_MISMATCH', 'This mutation does not apply to a thread.');
+                if (mutation.kind === 'retractMessage' || mutation.kind === 'reinstateMessage') {
+                    const current = await this.content.snapshot(actor.projectId, request.resourceId, 1_000_000);
+                    const message = current.messages.find(value => value.id === mutation.messageId);
+                    requireThat(message, 'NOT_FOUND', 'Message not found in this thread.');
+                    requireThat(mutation.kind === 'retractMessage' ? !message.retracted : message.retracted, 'NO_CHANGE', `The message is already ${mutation.kind === 'retractMessage' ? 'retracted' : 'visible'}.`);
+                }
+                const thread = prepareMutation(snapshot.thread, mutation);
+                operation = { id: uid(), actor, resourceId: request.resourceId, resourceType: 'thread', at, thread, mutation: mutation };
+            }
+            else {
+                requireThat(!threadMutationKinds.includes(mutation.kind), 'RESOURCE_TYPE_MISMATCH', 'This mutation does not apply to a note.');
+                const noteMutation = mutation;
+                const note = prepareNote(snapshot.note, noteMutation, actor, at);
+                await this.validateLinks(actor.projectId, note.links);
+                operation = { id: uid(), actor, resourceId: request.resourceId, resourceType: 'note', at, note, mutation: noteMutation };
+            }
+            this.control.update(state => {
+                const current = this.held(state, handle, floorId, fence);
+                current.state = 'COMMITTING';
+                state.pending[operation.id] = { id: operation.id, projectId: actor.projectId, resourceId: request.resourceId,
+                    resourceType: request.resourceType, floorRequestId: request.id, startingHead: snapshot.commit, kind: mutation.kind, actor };
+            });
+            return this.persist(operation);
+        });
+    }
+    finalize(pending, result) {
+        this.control.update(state => {
+            if (pending.floorRequestId) {
+                const request = state.requests[pending.floorRequestId];
+                this.finish(request, result ? 'COMMITTED' : 'FAILED', state);
+                if (result)
+                    request.result = result;
+            }
+            if (result && pending.resourceType !== 'project' && !state.resources[pending.resourceId])
+                state.resources[pending.resourceId] = { id: pending.resourceId, projectId: pending.projectId, type: pending.resourceType, fence: '0', queueSequence: '0', present: true };
+            if (result && 'changes' in result) {
+                for (const change of result.changes) {
+                    const resource = state.resources[change.resourceId] ?? { id: change.resourceId, projectId: pending.projectId, type: change.resourceType, fence: '0', queueSequence: '0', present: true };
+                    resource.type = change.resourceType;
+                    resource.present = change.action !== 'delete';
+                    state.resources[change.resourceId] = resource;
+                    if (change.action === 'delete')
+                        for (const request of values(state.requests).filter(value => value.resourceId === change.resourceId && activeStates.includes(value.state)))
+                            this.finish(request, 'FAILED', state);
+                }
+            }
+            delete state.pending[pending.id];
+            this.promote(state);
+        });
+    }
+    async persist(operation) {
+        const pending = this.control.view(s => s.pending[operation.id]);
+        try {
+            const result = await this.content.write(operation);
+            this.finalize(pending, result);
+            return result;
+        }
+        catch {
+            // Never replay a write: inspect its operation marker and committed head instead.
+            this.control.update(s => { s.projects[pending.projectId].recovering = true; });
+            let resolution;
+            try {
+                resolution = await this.content.resolve(pending);
+            }
+            catch {
+                resolution = { state: 'unknown' };
+            }
+            if (resolution.state === 'committed') {
+                this.finalize(pending, resolution.result);
+                this.control.update(s => { s.projects[pending.projectId].recovering = false; this.promote(s); });
+                return resolution.result;
+            }
+            if (resolution.state === 'absent') {
+                this.finalize(pending);
+                this.control.update(s => { s.projects[pending.projectId].recovering = false; this.promote(s); });
+                throw new BassfishError('WRITE_FAILED', 'The write was proven absent. No content mutation was retried.');
+            }
+            throw new BassfishError('OUTCOME_UNKNOWN', 'Storage outcome is unresolved. The project remains protected.');
+        }
+    }
+    async recover(projectId) {
+        for (const pending of this.control.view(s => values(s.pending).filter(p => p.projectId === projectId))) {
+            const result = await this.content.resolve(pending);
+            if (result.state === 'unknown')
+                return;
+            this.finalize(pending, result.state === 'committed' ? result.result : undefined);
+        }
+        this.control.update(s => { s.projects[projectId].recovering = false; this.promote(s); });
+    }
+    inspect() { this.sweep(); return this.control.view(s => ({ epoch: this.epoch, projects: values(s.projects), floors: values(s.requests).map(r => ({ ...this.statusIn(s, r), projectId: r.projectId, floorId: r.floorId, identityId: r.identityId, instanceId: r.instanceId })) })); }
+    hasPendingWork() { return this.control.view(s => values(s.requests).some(r => activeStates.includes(r.state)) || values(s.pending).length > 0 || values(s.projects).some(p => p.recovering)); }
+    forceRelease(floorId) {
+        this.sweep();
+        this.control.update(state => {
+            const request = values(state.requests).find(r => r.floorId === floorId);
+            requireThat(request?.state === 'HELD', 'NOT_HELD', 'Only a held floor can be force-released; committing writes are protected.');
+            this.finish(request, 'RELEASED', state);
+            this.promote(state);
+        });
+    }
+    async call(handle, name, input, signal, options = {}) {
+        requireThat(Object.hasOwn(schemas, name), 'UNKNOWN_TOOL', 'Unknown Bassfish operation.');
+        const parsed = schemas[name].safeParse(input);
+        requireThat(parsed.success, 'INVALID_ARGUMENT', 'Arguments do not match the operation schema.');
+        this.heartbeat(handle);
+        const args = parsed.data;
+        switch (name) {
+            case 'getSession': return this.info(handle);
+            case 'setAgentName': return this.requestName(handle, args.name);
+            case 'listAgents': return this.control.view(s => { const actor = this.actor(s, handle); return { agents: values(s.identities).filter(i => i.projectId === actor.projectId).map(i => ({ identityId: i.id, name: i.name, active: values(s.instances).some(a => a.identityId === i.id && a.active) })) }; });
+            case 'createThread': return this.createThread(handle, args.title, args.description);
+            case 'listThreads': {
+                const actor = this.control.view(s => { const a = this.actor(s, handle); this.ready(s, a.projectId); return a; });
+                const cursor = decodeCursor(args.cursor);
+                let threads = sortThreads(await this.content.listThreads(actor.projectId)).filter(thread => thread.state === args.state);
+                if (args.creatorIdentityId)
+                    threads = threads.filter(thread => thread.creator === args.creatorIdentityId);
+                if (args.titlePrefix)
+                    threads = threads.filter(thread => thread.title.startsWith(args.titlePrefix));
+                if (cursor)
+                    threads = threads.filter(thread => thread.createdAt > cursor[0] || (thread.createdAt === cursor[0] && thread.id > cursor[1]));
+                const limit = args.limit;
+                const page = threads.slice(0, limit);
+                const last = page.at(-1);
+                return { threads: page, nextCursor: threads.length > limit && last ? encodeCursor([last.createdAt, last.id]) : null };
+            }
+            case 'getThread': {
+                const actor = this.control.view(s => { const a = this.actor(s, handle); this.ready(s, a.projectId); return a; });
+                const thread = (await this.content.listThreads(actor.projectId)).find(value => value.id === args.threadId);
+                requireThat(thread, 'NOT_FOUND', 'Thread not found in this project.');
+                return thread;
+            }
+            case 'searchThreads': {
+                const actor = this.control.view(s => { const a = this.actor(s, handle); this.ready(s, a.projectId); return a; });
+                const query = String(args.query).toLowerCase();
+                const threads = sortThreads(await this.content.listThreads(actor.projectId)).filter(thread => thread.state === args.state && [thread.title, thread.description].some(value => value.toLowerCase().includes(query))).slice(0, args.limit);
+                return { threads };
+            }
+            case 'createNote': return this.createNote(handle, args);
+            case 'listNotes': {
+                const actor = this.control.view(s => { const a = this.actor(s, handle); this.ready(s, a.projectId); return a; });
+                const cursor = decodeCursor(args.cursor);
+                let notes = (await this.content.listNotes(actor.projectId)).filter(note => note.state === args.state);
+                if (args.pathPrefix)
+                    notes = notes.filter(note => note.path.startsWith(args.pathPrefix));
+                if (args.label)
+                    notes = notes.filter(note => note.labels.includes(args.label));
+                if (args.noteKind)
+                    notes = notes.filter(note => note.kind === args.noteKind);
+                if (args.creatorIdentityId)
+                    notes = notes.filter(note => note.creator === args.creatorIdentityId);
+                if (cursor)
+                    notes = notes.filter(note => note.path > cursor[0] || (note.path === cursor[0] && note.id > cursor[1]));
+                const limit = args.limit;
+                const page = notes.slice(0, limit);
+                const last = page.at(-1);
+                return { notes: page.map(note => this.noteMetadata(note)), nextCursor: notes.length > limit && last ? encodeCursor([last.path, last.id]) : null };
+            }
+            case 'searchNotes': {
+                const actor = this.control.view(s => { const a = this.actor(s, handle); this.ready(s, a.projectId); return a; });
+                const query = String(args.query).toLowerCase();
+                const notes = (await this.content.listNotes(actor.projectId)).filter(note => note.state === args.state && [note.path, note.title, ...note.labels, note.kind ?? ''].some(value => value.toLowerCase().includes(query))).slice(0, args.limit);
+                return { notes: notes.map(note => this.noteMetadata(note)) };
+            }
+            case 'requestFloor': {
+                const target = args.target;
+                const mode = options.taskCapable ? 'task' : 'ticket';
+                const result = target.type === 'project' ? await this.requestProjectFloor(handle, target.purpose, mode) : await this.requestResourceFloor(handle, target.type, target.id, mode);
+                const task = this.control.view(state => values(state.tasks).find(value => value.requestId === result.requestId));
+                return task?.status === 'working' ? { task: this.taskView(task) } : result;
+            }
+            case 'getFloorRequest': return this.status(handle, args.requestId);
+            case 'waitForFloor': return this.waitForFloor(handle, args.requestId, args.timeoutMs, signal);
+            case 'cancelFloorRequest': return this.cancelFloorRequest(handle, args.requestId);
+            case 'claimFloor': return this.claimFloor(handle, args.offerId, 20);
+            case 'readFloor': {
+                const credential = args.floor;
+                return this.readFloor(handle, credential.id, credential.fencingToken, args.cursor);
+            }
+            case 'releaseFloor': {
+                const credential = args.floor;
+                return this.releaseFloor(handle, credential.id, credential.fencingToken);
+            }
+            case 'commitFloor': {
+                const credential = args.floor;
+                return this.commitFloor(handle, credential.id, credential.fencingToken, args.baseRevision, toMutation(args.mutation));
+            }
+            case 'getNoteOutline': {
+                const credential = args.floor;
+                return this.noteOutline(handle, credential.id, credential.fencingToken);
+            }
+            case 'findInNote': {
+                const credential = args.floor;
+                return this.findNote(handle, credential.id, credential.fencingToken, args.query, args.mode, args.limit);
+            }
+            case 'inspectSnapshot': {
+                const credential = args.floor;
+                return this.projectSnapshotInfo(handle, credential.id, credential.fencingToken);
+            }
+            case 'searchProjectNotes': {
+                const credential = args.floor;
+                return this.projectSearch(handle, credential.id, credential.fencingToken, args.query, args.states, args.limit, args.cursor);
+            }
+            case 'searchProjectNoteHistory': {
+                const credential = args.floor;
+                return this.projectHistorySearch(handle, credential.id, credential.fencingToken, args.query, args.noteId, args.states, args.limit, args.cursor);
+            }
+            case 'exportSnapshot': {
+                const credential = args.floor;
+                return this.exportProject(handle, credential.id, credential.fencingToken);
+            }
+            case 'listSnapshotHistory': {
+                const credential = args.floor;
+                return this.projectHistoryList(handle, credential.id, credential.fencingToken, args.limit, args.cursor);
+            }
+            case 'previewSnapshotRestore': {
+                const credential = args.floor;
+                return this.previewProjectRestore(handle, credential.id, credential.fencingToken, args.targetCommit, args.limit, args.cursor);
+            }
+            case 'restoreSnapshot': {
+                const credential = args.floor;
+                return this.restoreProject(handle, credential.id, credential.fencingToken, args.previewToken);
+            }
+            case 'listHistory': {
+                const credential = args.floor;
+                return this.resourceHistory(handle, credential.id, credential.fencingToken, args.offset, args.limit);
+            }
+            case 'readRevision': {
+                const credential = args.floor;
+                return this.resourceAt(handle, credential.id, credential.fencingToken, args.revision, 20, args.cursor);
+            }
+            case 'diffRevision': {
+                const credential = args.floor;
+                return this.diffResource(handle, credential.id, credential.fencingToken, args.revision);
+            }
+            case 'previewRestore': {
+                const credential = args.floor;
+                return this.previewRestore(handle, credential.id, credential.fencingToken, args.revision);
+            }
+            case 'restoreRevision': {
+                const credential = args.floor;
+                return this.restoreRevision(handle, credential.id, credential.fencingToken, args.previewToken);
+            }
+        }
+    }
+}
+//# sourceMappingURL=service.js.map