@ours.network/fleet 1.2.0-nightly.9 → 2.0.1

package/dist/web/resource-views.js

@@ -0,0 +1,519 @@
+import { relative, resolve, sep } from 'node:path';
+import { agentsRoot, tmpRoot, stateRoot, defaultConfigPath, fleetDDir } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { observeFleetResources } from '../application/resource-observer.js';
+export async function abortableProjection(read, signal) {
+    signal.throwIfAborted();
+    let onAbort;
+    const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason ?? new Error('resource projection aborted'));
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([read, aborted]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+export const RESOURCE_FRAME_BYTES = 512 * 1024;
+export const RESOURCE_PENDING_BYTES = 8 * 1024 * 1024;
+export const RESOURCE_ASSEMBLY_BYTES = 16 * 1024 * 1024;
+const CHUNK_BYTES = 256 * 1024;
+/** Minimum spacing of activity-only follow-up captures of one view. */
+export const ACTIVITY_CAPTURE_INTERVAL_MS = 1000;
+/** Lazily yield byte chunks so backpressure never queues an entire large record.
+ * Base64 prevents splitting a Unicode scalar from corrupting JSON/SSE parsing. */
+export function* resourceFrames(envelope) {
+    const bytes = Buffer.from(JSON.stringify(envelope));
+    if (bytes.length > RESOURCE_ASSEMBLY_BYTES)
+        throw new Error('resource assembly limit exceeded');
+    const ordinary = { event: 'resource', data: envelope };
+    if (Buffer.byteLength(`event: resource\ndata: ${bytes.toString('utf8')}\n\n`) <= RESOURCE_FRAME_BYTES) {
+        yield ordinary;
+        return;
+    }
+    const id = `${envelope.viewId}:${envelope.subscriptionEpoch}:${envelope.sequence}`;
+    const binding = { protocolVersion: 1, id, producerGeneration: envelope.producerGeneration,
+        viewId: envelope.viewId, subscriptionEpoch: envelope.subscriptionEpoch, revision: envelope.revision,
+        sequence: envelope.sequence };
+    yield { event: 'resource-chunk', data: { ...binding, type: 'start', totalBytes: bytes.length, parts: Math.ceil(bytes.length / CHUNK_BYTES) } };
+    for (let offset = 0, index = 0; offset < bytes.length; offset += CHUNK_BYTES, index++) {
+        yield { event: 'resource-chunk', data: { ...binding, type: 'chunk', index, data: bytes.subarray(offset, offset + CHUNK_BYTES).toString('base64') } };
+    }
+    yield { event: 'resource-chunk', data: { ...binding, type: 'commit', totalBytes: bytes.length } };
+}
+/** One Fleet HTTP writer. The active record owns the assembly budget;
+ * waiting live records share the smaller pending-output budget. */
+export class ResourceOutput {
+    response;
+    signal;
+    failed;
+    #pending = [];
+    #pendingBytes = 0;
+    #active;
+    #closed = false;
+    #releaseDrain;
+    #abort = () => this.close();
+    constructor(response, signal, failed) {
+        this.response = response;
+        this.signal = signal;
+        this.failed = failed;
+        if (signal.aborted)
+            this.close();
+        else {
+            signal.addEventListener('abort', this.#abort, { once: true });
+            response.once('close', this.#abort);
+        }
+    }
+    send(envelope, admitted) {
+        if (this.#closed)
+            return Promise.reject(new Error('resource output closed'));
+        const bytes = Buffer.byteLength(JSON.stringify(envelope));
+        if (bytes > RESOURCE_ASSEMBLY_BYTES)
+            return this.#fail(new Error('resource assembly limit exceeded'));
+        if (this.#active && this.#pendingBytes + bytes > RESOURCE_PENDING_BYTES) {
+            return this.#fail(new Error('resource pending limit exceeded'));
+        }
+        admitted?.();
+        return new Promise((resolve, reject) => {
+            const item = { envelope, bytes, resolve, reject };
+            if (!this.#active) {
+                this.#active = item;
+                void this.#pump();
+            }
+            else {
+                this.#pending.push(item);
+                this.#pendingBytes += bytes;
+            }
+        });
+    }
+    #fail(error) {
+        this.close(error);
+        this.failed(error);
+        return Promise.reject(error);
+    }
+    close(error = new Error('resource output closed')) {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.signal.removeEventListener('abort', this.#abort);
+        this.response.removeListener('close', this.#abort);
+        this.#releaseDrain?.();
+        this.#active?.reject(error);
+        for (const item of this.#pending.splice(0))
+            item.reject(error);
+        this.#pendingBytes = 0;
+        if (!this.response.destroyed && !this.response.writableEnded)
+            this.response.end();
+    }
+    async #pump() {
+        try {
+            while (this.#active && !this.#closed) {
+                const item = this.#active;
+                for (const frame of ('views' in item.envelope ? [{ event: 'resource-coverage', data: item.envelope }] : resourceFrames(item.envelope))) {
+                    if (this.#closed)
+                        break;
+                    const writable = this.response.write(`event: ${frame.event}\ndata: ${JSON.stringify(frame.data)}\n\n`);
+                    if (!writable)
+                        await this.#drain();
+                }
+                if (this.#closed)
+                    break;
+                item.resolve();
+                this.#active = this.#pending.shift();
+                if (this.#active)
+                    this.#pendingBytes -= this.#active.bytes;
+            }
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error('resource output failed');
+            this.close(failure);
+            this.failed(failure);
+        }
+    }
+    #drain() {
+        if (this.#closed)
+            return Promise.resolve();
+        return new Promise(resolve => {
+            const release = () => {
+                this.response.removeListener('drain', release);
+                this.#releaseDrain = undefined;
+                resolve();
+            };
+            this.#releaseDrain = release;
+            this.response.once('drain', release);
+        });
+    }
+}
+export function canonicalResourceDescriptor(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw Error('invalid resource descriptor');
+    const value = input;
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(value.viewId) || !['directory', 'roles', 'tasks', 'task-lists', 'configuration', 'previews', 'task-layout', 'creation-action', 'action', 'member-addition', 'login', 'onboarding-health', 'subscriptions'].includes(value.resource)
+        || Object.keys(value).some(key => !['viewId', 'resource', 'includeTemporary', 'includeDefinitions', 'ids', 'state', 'list', 'groupByList', 'includeDeleting', 'entityId', 'receiptId', 'provider'].includes(key)))
+        throw Error('invalid resource descriptor');
+    for (const key of ['includeTemporary', 'includeDefinitions', 'groupByList', 'includeDeleting'])
+        if (value[key] !== undefined && typeof value[key] !== 'boolean')
+            throw Error('invalid resource descriptor');
+    if (value.ids !== undefined && (!Array.isArray(value.ids) || value.ids.length > 500 || value.ids.some(id => typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,120}$/.test(id))))
+        throw Error('invalid resource ids');
+    if (value.state !== undefined && !['all', 'backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'].includes(value.state))
+        throw Error('invalid resource state');
+    if (value.list !== undefined && (typeof value.list !== 'string' || value.list.length > 256))
+        throw Error('invalid resource list');
+    for (const key of ['entityId', 'receiptId'])
+        if (value[key] !== undefined && (typeof value[key] !== 'string' || !/^[A-Za-z0-9_-]{1,120}$/.test(value[key])))
+            throw Error('invalid resource target');
+    if (['task-layout', 'creation-action', 'action', 'member-addition', 'login'].includes(value.resource) && !value.entityId)
+        throw Error('resource target required');
+    if (value.resource === 'member-addition' && !value.receiptId)
+        throw Error('receipt required');
+    if (value.resource === 'login' && !['claude', 'codex'].includes(value.provider ?? ''))
+        throw Error('provider required');
+    return { ...value, ...(value.ids ? { ids: [...new Set(value.ids)] } : {}) };
+}
+export class ResourceBindingError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/** Same committed snapshot/ready/bound-read contract as Messenger. No controllers,
+ * notification reads or presence are acquired by this delivery owner. */
+export class FleetResourceViews {
+    scope;
+    project;
+    configurationInputs;
+    activityCaptureIntervalMs;
+    producerGeneration = randomUUID();
+    connections = new Map();
+    constructor(scope, project, configurationInputs = () => [], activityCaptureIntervalMs = ACTIVITY_CAPTURE_INTERVAL_MS) {
+        this.scope = scope;
+        this.project = project;
+        this.configurationInputs = configurationInputs;
+        this.activityCaptureIntervalMs = activityCaptureIntervalMs;
+    }
+    open(response, owner, authorized) {
+        const id = randomUUID(), controller = new AbortController();
+        let connection;
+        let timer;
+        let healthTimer;
+        const close = () => {
+            if (controller.signal.aborted)
+                return;
+            controller.abort();
+            clearInterval(timer);
+            clearInterval(healthTimer);
+            this.connections.delete(id);
+            if (connection) {
+                for (const view of connection.views.values())
+                    this.retire(view);
+                connection.views.clear();
+                connection.output.close();
+            }
+            response.off('close', close);
+        };
+        const output = new ResourceOutput(response, controller.signal, close);
+        const observer = observeFleetResources(this.scope, state => {
+            if (!connection || controller.signal.aborted)
+                return;
+            if (state.health !== 'healthy') {
+                const pending = [...connection.views.values()].map(view => {
+                    view.failed = true;
+                    view.rejectInitial(Error('resource observation unavailable'));
+                    view.controller.abort();
+                    return this.emit(connection, view, 'health', { healthy: false, reason: state.health === 'unsupported' ? 'unsupported' : 'upstream_unavailable' });
+                });
+                if (!pending.length)
+                    response.write(`event: resource-service-health\ndata: ${JSON.stringify({ protocolVersion: 1, healthy: false, reason: state.health === 'unsupported' ? 'unsupported' : 'upstream_unavailable' })}\n\n`);
+                void Promise.allSettled(pending).then(close);
+            }
+            else
+                for (const view of connection.views.values())
+                    if (view.source.snapshot().position !== view.scheduledPosition)
+                        this.schedule(connection, view);
+        }, controller.signal);
+        connection = { id, owner, controller, output, views: new Map(), epochs: new Map(), observer, tail: Promise.resolve(), close };
+        this.connections.set(id, connection);
+        response.once('close', close);
+        response.write(`event: resource-connection\ndata: ${JSON.stringify({ protocolVersion: 1, connectionId: id, producerGeneration: this.producerGeneration, continuity: 'reset', baselineRequired: true })}\n\n`);
+        if (observer.snapshot().health !== 'healthy') {
+            response.write(`event: resource-service-health\ndata: ${JSON.stringify({ protocolVersion: 1, healthy: false, reason: observer.snapshot().health === 'unsupported' ? 'unsupported' : 'upstream_unavailable' })}\n\n`);
+            close();
+        }
+        else {
+            // Preserve credential retirement timing independently of sparse wire health.
+            timer = setInterval(() => {
+                if (!authorized()) {
+                    close();
+                    return;
+                }
+            }, 2000);
+            timer.unref();
+            healthTimer = setInterval(() => {
+                if (!authorized()) {
+                    close();
+                    return;
+                }
+                this.coverage(connection).catch(close);
+                if (!connection.views.size)
+                    response.write(': keepalive\n\n');
+            }, 15000);
+            healthTimer.unref();
+        }
+        return { connectionId: id, close };
+    }
+    register(owner, connectionId, viewId, epoch, input) {
+        const connection = this.get(owner, connectionId);
+        let descriptor;
+        try {
+            descriptor = canonicalResourceDescriptor(input);
+        }
+        catch {
+            throw new ResourceBindingError(400, 'invalid resource descriptor');
+        }
+        if (descriptor.viewId !== viewId || !Number.isSafeInteger(epoch) || epoch < 1)
+            throw new ResourceBindingError(400, 'invalid resource epoch');
+        if ((connection.epochs.get(viewId) ?? 0) >= epoch)
+            throw new ResourceBindingError(409, 'obsolete resource epoch');
+        if (connection.observer.snapshot().health !== 'healthy')
+            throw new ResourceBindingError(503, 'resource observation unavailable');
+        if (!connection.epochs.has(viewId) && connection.epochs.size >= 256)
+            throw new ResourceBindingError(503, 'resource epoch capacity exceeded');
+        if (!connection.views.has(viewId) && connection.views.size >= 64)
+            throw new ResourceBindingError(409, 'resource view capacity exceeded');
+        const old = connection.views.get(viewId);
+        if (old)
+            this.retire(old);
+        let resolveInitial, rejectInitial;
+        const initial = new Promise((resolve, reject) => { resolveInitial = resolve; rejectInitial = reject; });
+        void initial.catch(() => { });
+        const controller = new AbortController();
+        const source = connection.observer.cursor(path => this.affects(descriptor, path), controller.signal);
+        // Independent agents contribute ordered, last-observed statuses and completed
+        // preview records. Activity wakes follow-up reads without revoking structural
+        // capture; the read still certifies only its starting source watermark.
+        const captureSource = descriptor.resource === 'directory' || descriptor.resource === 'roles' || descriptor.resource === 'previews'
+            ? connection.observer.cursor(path => this.affects(descriptor, path, true), controller.signal)
+            : source;
+        const view = { source, captureSource, scheduledPosition: -1, descriptor, epoch, baselineId: randomUUID(), controller, revision: 0, sequence: 0, dirty: false, running: false, failed: false, initial, resolveInitial, rejectInitial };
+        connection.views.set(viewId, view);
+        connection.epochs.set(viewId, epoch);
+        this.schedule(connection, view);
+        return { subscriptionEpoch: epoch, baselineId: view.baselineId };
+    }
+    remove(owner, connectionId, viewId, epoch) {
+        const connection = this.get(owner, connectionId), view = connection.views.get(viewId);
+        if (typeof viewId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(viewId) || !Number.isSafeInteger(epoch) || epoch < 1)
+            throw new ResourceBindingError(400, 'invalid resource epoch');
+        if (!connection.epochs.has(viewId) && connection.epochs.size >= 256)
+            throw new ResourceBindingError(503, 'resource epoch capacity exceeded');
+        // Independent DELETE can arrive before the POST it retires.
+        connection.epochs.set(viewId, Math.max(connection.epochs.get(viewId) ?? 0, epoch));
+        if (view && epoch >= view.epoch) {
+            this.retire(view);
+            connection.views.delete(viewId);
+        }
+    }
+    async bound(owner, connectionId, viewId, epoch, baselineId) {
+        const connection = this.get(owner, connectionId), view = connection.views.get(viewId);
+        if (!view || view.epoch !== epoch || view.baselineId !== baselineId)
+            throw new ResourceBindingError(409, 'resource binding mismatch');
+        const baseline = await view.initial;
+        if (!this.current(connection, view) || view.failed)
+            throw new ResourceBindingError(409, 'resource binding retired');
+        return baseline;
+    }
+    close() { for (const connection of this.connections.values())
+        connection.close(); }
+    get(owner, id) {
+        const connection = this.connections.get(id);
+        if (!connection || connection.owner !== owner)
+            throw new ResourceBindingError(409, 'unknown resource connection');
+        return connection;
+    }
+    current(connection, view) { return !connection.controller.signal.aborted && !view.controller.signal.aborted && connection.views.get(view.descriptor.viewId) === view; }
+    retire(view) { clearTimeout(view.activityTimer); view.activityTimer = undefined; view.controller.abort(); view.rejectInitial(new ResourceBindingError(409, 'resource binding retired')); }
+    emit(connection, view, kind, payload, source) {
+        return connection.output.send({ protocolVersion: 1, producerGeneration: this.producerGeneration, viewId: view.descriptor.viewId, subscriptionEpoch: view.epoch, baselineId: view.baselineId, sequence: view.sequence + 1, revision: view.revision, kind, payload, ...(source ? { source } : {}) }, () => { view.sequence++; if (source || kind === 'ready')
+            view.qualifiedAt = Date.now(); });
+    }
+    // Admission allocates sequences atomically; the existing writer keeps this
+    // complete batch behind any active chunk assembly and earlier data records.
+    coverage(connection) {
+        const now = Date.now();
+        const eligible = [...connection.views.values()].filter(view => this.current(connection, view) && !view.failed && !view.running && !view.dirty && view.payload !== undefined && view.covered && view.covered.health === 'healthy' && view.covered.position === view.source.snapshot().position && now - (view.qualifiedAt ?? 0) >= 15000);
+        if (!eligible.length)
+            return Promise.resolve();
+        const views = eligible.map(view => ({ protocolVersion: 1, producerGeneration: this.producerGeneration, viewId: view.descriptor.viewId, subscriptionEpoch: view.epoch, baselineId: view.baselineId, sequence: view.sequence + 1, revision: view.revision, source: view.covered }));
+        return connection.output.send({ protocolVersion: 1, producerGeneration: this.producerGeneration, views }, () => { for (const view of eligible) {
+            view.sequence++;
+            view.qualifiedAt = now;
+        } });
+    }
+    affects(descriptor, path, structural = false) {
+        if (descriptor.resource === 'configuration') {
+            const manifest = resolve(this.scope.configPath ?? defaultConfigPath());
+            const root = resolve(splitRootFor(manifest)), changed = resolve(path);
+            const within = (candidate, parent) => {
+                const local = relative(parent, candidate);
+                return local === '' || (local !== '..' && !local.startsWith('..' + sep));
+            };
+            // Configuration and provenance read the manifest and split definitions;
+            // loadConfig also rejects legacy YAML files in the global fleet.d root.
+            // Ancestor replacement/unknown directory wakes remain conservative.
+            const legacy = resolve(fleetDDir());
+            return within(changed, root) || within(root, changed) || within(manifest, changed)
+                || within(changed, legacy) || within(legacy, changed)
+                || this.configurationInputs().some(input => within(resolve(input), changed));
+        }
+        // An explicitly selected manifest may use any pathname, including one
+        // otherwise reserved for an independent task receipt.
+        if (this.scope.configPath && resolve(path) === resolve(this.scope.configPath))
+            return true;
+        // Adopted Codex history, telemetry and cache commits are not canonical
+        // Fleet preview inputs. Keep credentials, unknown paths and directory-level
+        // events conservative, and never override explicit config or role roots.
+        const roots = this.scope.roots ?? [agentsRoot(), tmpRoot()];
+        if (descriptor.resource === 'previews'
+            && /^(?:history\.jsonl|models_cache\.json|(?:thread_history|state|logs|queue|goals)_\d+\.sqlite(?:-wal|-shm|-journal)?)$/.test(relative(resolve(homedir(), '.codex'), path))
+            && !roots.some(root => { const local = relative(resolve(root), path); return local === '' || (local !== '..' && !local.startsWith('..' + sep)); }))
+            return false;
+        // Preview selection reads role config/state and conversation ledgers, never
+        // task layout run/operation/brief receipts. A worker may commit several of
+        // these while that independent canonical preview read is in flight.
+        // Unknown paths and directory-level events retain full invalidation.
+        if (descriptor.resource === 'previews' && /^task-[A-Za-z0-9_-]+(?:\.op\.json|\.json|\.brief\.md)$/.test(relative(resolve(stateRoot(), 'layouts'), path)))
+            return false;
+        // Only classify known activity writes under the configured role roots.
+        // Parent/unknown events and every other file retain full invalidation.
+        // The canonical web producer atomically replaces hashed checkpoint files,
+        // once per ledger advance of any role. No projection reads these delivery
+        // acknowledgements, so they neither fence a capture nor wake a follow-up.
+        if (/^[a-f0-9]{64}\.json$/.test(relative(resolve(stateRoot(), 'web', 'notification-outboxes'), path)))
+            return false;
+        for (const root of roots) {
+            const parts = relative(resolve(root), path).split(sep);
+            if (parts[0] === '..')
+                continue;
+            // Both session backends append diagnostic events as well as durable
+            // conversation events; ACP usage updates also persist observed usage.
+            // Monitor cursor/state and its presented status are per-agent activity.
+            // None changes role membership/configuration. Keep these as full wakes.
+            if (structural && parts.length === 2 && ['.session-events.jsonl', '.session-events.jsonl.1', '.subscription-usage.json', '.notify-cursor', '.monitor-state.json', '.monitor-status'].includes(parts[1]))
+                return false;
+            if (parts.length < 3 || parts[1] !== '.conversation')
+                continue;
+            if (structural && (descriptor.resource === 'directory' || descriptor.resource === 'roles'))
+                return false;
+            if (descriptor.resource === 'previews') {
+                // conversationPreview reads bounded completed records, independently per
+                // role. These known writer paths still wake ordered follow-up captures.
+                // Unknown children, parent replacement and explicit config paths retain
+                // their capture fence; do not waive the whole conversation subtree.
+                if (structural && parts.length === 3 && /^(?:events-\d{6}\.jsonl|manifest\.json)$/.test(parts[2]))
+                    return false;
+                return (descriptor.ids ?? []).includes(parts[0]);
+            }
+            // Directory and roles intentionally remain conservative: live status
+            // includes activity. Configuration was classified by its inputs above.
+        }
+        return true;
+    }
+    schedule(connection, view, due = false) {
+        if (!this.current(connection, view) || view.failed)
+            return;
+        // Agent activity (ledger appends, status files) changes previews and status
+        // continuously while an agent works. Without a structural change since the
+        // latest capture began, coalesce those wakes into one trailing capture per
+        // interval instead of re-projecting every role after every append.
+        const wait = !due && view.captureSource !== view.source && view.capturedAt !== undefined
+            && view.captureSource.snapshot().position === view.capturedStructure
+            ? this.activityCaptureIntervalMs - (Date.now() - view.capturedAt) : 0;
+        if (wait > 0) {
+            view.scheduledPosition = view.source.snapshot().position;
+            view.dirty = true;
+            if (!view.running && !view.activityTimer) {
+                // The trailing capture runs when its timer fires, whatever the clock reads.
+                view.activityTimer = setTimeout(() => { view.activityTimer = undefined; this.schedule(connection, view, true); }, Math.min(wait, this.activityCaptureIntervalMs));
+                view.activityTimer.unref?.();
+            }
+            return;
+        }
+        clearTimeout(view.activityTimer);
+        view.activityTimer = undefined;
+        view.scheduledPosition = view.source.snapshot().position;
+        view.dirty = true;
+        if (view.running)
+            return;
+        view.running = true;
+        const task = connection.tail.then(async () => {
+            // Resolved projection promises must not starve HTTP, timers or native
+            // watch delivery. Preserve serialization and coalesce this event batch.
+            await yieldToEventLoop();
+            if (!this.current(connection, view) || view.failed)
+                return;
+            await this.refresh(connection, view);
+        });
+        connection.tail = task.catch(() => { });
+        void task.finally(() => { view.running = false; if (view.dirty)
+            this.schedule(connection, view); }).catch(connection.close);
+    }
+    async refresh(connection, view) {
+        try {
+            if (!view.dirty || !this.current(connection, view))
+                return;
+            view.dirty = false;
+            view.capturedAt = Date.now();
+            view.capturedStructure = view.captureSource.snapshot().position;
+            let payload, source;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                view.controller.signal.throwIfAborted();
+                const before = view.captureSource.snapshot();
+                const covered = view.source.snapshot();
+                payload = await abortableProjection(this.project(view.descriptor, view.controller.signal, connection.owner), view.controller.signal);
+                view.controller.signal.throwIfAborted();
+                const after = view.captureSource.snapshot();
+                if (after.health !== 'healthy')
+                    throw Error('resource observation unavailable');
+                // Certify only the starting wake barrier. Status commits during the
+                // asynchronous canonical read stay dirty and are drained in order by
+                // the next serialized capture, even if this read happened to see them.
+                if (before.position === after.position) {
+                    source = covered;
+                    break;
+                }
+            }
+            if (!source)
+                throw Error('resource projection unstable');
+            if (!this.current(connection, view))
+                return;
+            const first = view.payload === undefined, changed = first || JSON.stringify(payload, (key, value) => key === 'observedAt' ? undefined : value) !== JSON.stringify(view.payload, (key, value) => key === 'observedAt' ? undefined : value);
+            view.covered = source;
+            if (changed) {
+                view.revision++;
+                await this.emit(connection, view, 'snapshot', payload, source);
+                if (!this.current(connection, view))
+                    return;
+                view.payload = payload;
+            }
+            if (first) {
+                await this.emit(connection, view, 'ready', { baselineId: view.baselineId, source });
+                if (this.current(connection, view))
+                    view.resolveInitial({ payload, source, producerGeneration: this.producerGeneration, revision: view.revision, baselineId: view.baselineId, descriptor: view.descriptor });
+            }
+        }
+        catch (error) {
+            if (!this.current(connection, view))
+                return;
+            view.failed = true;
+            view.rejectInitial(error instanceof Error ? error : Error('projection failed'));
+            await this.emit(connection, view, 'resync', { reason: 'projection_unavailable' }).catch(connection.close);
+        }
+    }
+}

package/dist/web/runtime.d.ts

@@ -2,8 +2,10 @@ import { type WebServer } from './server.js';
 import { type WebAccessConfig } from './access.js';
 export interface StartWebOptions {
     configPath?: string;
+    /** Separate console state for an independently launched gateway. */
+    webStateDir?: string;
+    control?: boolean;
     port?: number;
-    open?: boolean;
     binPath: string;
     log?(line: string): void;
     bind?: string;