@meshline/sdk 0.0.0-stage → 0.1.0-alpha.1

package/dist/transport/subscription.js

@@ -0,0 +1,169 @@
+import { createAbortController } from '../runtime/abort.js';
+import { ProtocolError } from '../errors.js';
+import { canonicalJson, parseJson, requireObject } from '../protocol/json.js';
+import { AsyncPulse } from '../runtime/async-pulse.js';
+import { abortScope, throwIfAborted } from '../runtime/clock.js';
+import { RelayError } from './relay-error.js';
+function transient(error) {
+    if (error instanceof RelayError)
+        return ['unauthorized', 'temporarily_unavailable', 'bad_gateway', 'rate_limited'].includes(error.code);
+    if (error instanceof ProtocolError)
+        return ['socket_closed', 'socket_error', 'notification_overflow'].includes(error.code);
+    return error instanceof TypeError || error instanceof Error && (['AbortError', 'TimeoutError'].includes(error.name) || 'code' in error);
+}
+/** One full-replacement stream for one method and relay. Created through RelayClient. */
+export class RelaySubscription {
+    method;
+    options;
+    transport;
+    #wake = new AsyncPulse();
+    #stop = createAbortController();
+    #pending = createAbortController();
+    #scope;
+    #pendingScope;
+    #empty;
+    #detach;
+    #desired;
+    #worker;
+    #connection;
+    #applied;
+    #appliedGeneration;
+    #lastError;
+    #disposal;
+    constructor(method, empty, options, transport) {
+        this.method = method;
+        this.options = options;
+        this.transport = transport;
+        this.#empty = canonicalJson(requireObject(empty));
+        this.#scope = abortScope([options.signal, transport.lifetime, this.#stop.signal]);
+        this.#pendingScope = abortScope([transport.lifetime, this.#pending.signal]);
+        this.#detach = transport.onConnected(() => this.#wake.pulse());
+    }
+    get lastError() { return this.#lastError; }
+    /** Snapshots and coalesces updates, including empty sets; it does not wait for remote acknowledgement. */
+    update(request) {
+        throwIfAborted(this.#scope.signal);
+        this.#desired = canonicalJson(requireObject(request));
+        this.#wake.pulse();
+        this.#worker ??= this.#run();
+    }
+    #report(error) {
+        this.#lastError = error;
+        try {
+            Promise.resolve(this.options.onError?.(error)).catch(observer => { this.#lastError = new AggregateError([error, observer], 'Subscription and error observer failed.'); });
+        }
+        catch (observer) {
+            this.#lastError = new AggregateError([error, observer], 'Subscription and error observer failed.');
+        }
+    }
+    #subscribed() {
+        try {
+            Promise.resolve(this.options.onSubscribed?.()).catch(error => this.#report(error));
+        }
+        catch (error) {
+            this.#report(error);
+        }
+    }
+    async #send(connection, json) {
+        throwIfAborted(this.#pendingScope.signal);
+        try {
+            const result = await connection.request(this.method, requireObject(parseJson(json)), this.#pendingScope.signal);
+            if (result !== null)
+                throw new ProtocolError('invalid_response', 'Subscription replacement must acknowledge with JSON null.');
+        }
+        catch (error) {
+            if (!(error instanceof RelayError))
+                connection.retire(new ProtocolError('socket_closed', 'Subscription outcome is unknown; reconnect before replacing the set.', { cause: error }));
+            throw error;
+        }
+    }
+    async #retry() {
+        const timer = createAbortController();
+        const scope = abortScope([this.#scope.signal, timer.signal]);
+        const delay = this.transport.clock.delay(5000, scope.signal).then(() => this.#wake.pulse(), error => { if (!scope.signal.aborted)
+            this.#report(error); });
+        try {
+            await this.#wake.wait(this.#scope.signal);
+            this.#wake.pulse();
+        }
+        finally {
+            timer.abort();
+            await delay;
+            scope.dispose();
+        }
+    }
+    async #run() {
+        try {
+            for (;;) {
+                await this.#wake.wait(this.#scope.signal);
+                try {
+                    const connection = await this.transport.ready(this.#scope.signal);
+                    // Take the latest set only after this relay becomes ready.
+                    const request = this.#desired;
+                    if (request === undefined)
+                        continue;
+                    if (this.#applied === request && this.#appliedGeneration === connection.generation)
+                        continue;
+                    throwIfAborted(this.#scope.signal);
+                    this.#applied = undefined;
+                    this.#connection = connection;
+                    await this.#send(connection, request);
+                    throwIfAborted(this.#scope.signal);
+                    this.#applied = request;
+                    this.#appliedGeneration = connection.generation;
+                    if (request !== this.#empty)
+                        this.#subscribed();
+                }
+                catch (error) {
+                    if (this.#scope.signal.aborted) {
+                        if (this.#pendingScope.signal.aborted && !this.transport.lifetime.aborted)
+                            this.#report(error);
+                        break;
+                    }
+                    this.#report(error);
+                    if (transient(error))
+                        await this.#retry();
+                }
+            }
+        }
+        catch (error) {
+            if (!this.#scope.signal.aborted)
+                this.#report(error);
+        }
+    }
+    /** Drains the in-flight replacement and clears this exact connection within one shared five-second budget. */
+    dispose() {
+        return this.#disposal ??= (async () => {
+            this.#stop.abort(new DOMException('Subscription stopped.', 'AbortError'));
+            this.#detach();
+            const timer = createAbortController();
+            const budget = this.transport.clock.delay(5000, timer.signal).then(() => this.#pending.abort(new DOMException('Subscription cleanup timed out.', 'TimeoutError')), error => {
+                if (!timer.signal.aborted) {
+                    this.#pending.abort(error);
+                    this.#report(error);
+                }
+            });
+            try {
+                await this.#worker;
+                const connection = this.#connection;
+                if (connection && !connection.failure) {
+                    try {
+                        await this.#send(connection, this.#empty);
+                    }
+                    catch (error) {
+                        connection.retire(new ProtocolError('socket_closed', 'Subscriptions could not be cleared; retire the old connection.', { cause: error }));
+                        this.#report(error);
+                    }
+                }
+            }
+            finally {
+                timer.abort();
+                await budget;
+                this.#scope.dispose();
+                this.#pendingScope.dispose();
+                this.transport.closed();
+            }
+        })();
+    }
+}
+//# sourceMappingURL=subscription.js.map

package/dist/transport/subscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../src/transport/subscription.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@meshline/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "description": "Meshline protocol and client SDK for TypeScript",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/meshline-network/sdk.git",
+    "directory": "typescript/packages/sdk"
+  },
+  "dependencies": {
+    "@multiformats/multiaddr": "13.0.3",
+    "@noble/ciphers": "2.4.0",
+    "@noble/curves": "2.4.0",
+    "@noble/hashes": "2.4.0",
+    "multiformats": "14.0.5",
+    "tr46": "6.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}

package/src/channels/repository.ts

@@ -0,0 +1,244 @@
+import { ProtocolError, StateConflictError } from '../errors.js';
+import {
+    applyChannelPostEdit, channelDescriptorCodec, channelEventCodec, channelPayloadCodec, channelPostCodec, channelReadPageCodec, channelResolveResultCodec,
+    validateChannelPayload, validateChannelReadPage, validateChannelReadQuery, validateChannelRef, validateChannelPostRef, verifyChannelDescriptor, verifyChannelEvent,
+    type ChannelDescriptor, type ChannelEvent, type ChannelPayload, type ChannelPost, type ChannelPostRef, type ChannelReadPage, type ChannelReadQuery, type ChannelRef, type ChannelResolveResult,
+} from '../models/channels.js';
+import type { DeviceCertificate } from '../models/identity.js';
+import type { ContentReference, MessageBody } from '../models/content.js';
+import type { NetworkContext } from '../protocol/context.js';
+import { canonicalJson, requireObject, requireSafeInteger, type JsonObject } from '../protocol/json.js';
+import type { MeshlineStore, QueryReader, RecordKey, RecordQuery, StoredRecord, StoreMutation, StoreSnapshot } from '../storage/store.js';
+import { updateStore } from '../storage/transaction.js';
+import { snapshotReader } from '../messages/repository.js';
+
+export interface ChannelInfo { readonly ref: ChannelRef; readonly descriptor?: ChannelDescriptor; readonly isFollowed: boolean }
+export interface ChannelPostInfo { readonly ref: ChannelPostRef; readonly messageId: string; readonly author: string; readonly acceptedAt: number; readonly body?: MessageBody; readonly attachments?: readonly ContentReference[] }
+export interface ChannelPostChange { readonly ref: ChannelPostRef; readonly kind: 'added' | 'edited' | 'deleted'; readonly info?: ChannelPostInfo }
+export interface ChannelChanges { readonly channel?: ChannelInfo; readonly posts: readonly ChannelPostChange[] }
+export interface ChannelRecord { readonly channel: ChannelRef; readonly descriptor?: ChannelDescriptor; readonly syncSequence: number; readonly isFollowed: boolean }
+interface PostRecord { sequence: number; appliedThrough: number; isDeleted: boolean; messageId?: string; author?: string; acceptedAt?: number; original?: ChannelPost; post?: ChannelPost }
+export type ChannelOperationMethod = 'channel.create' | 'channel.update' | 'channel.close' | 'channel.post' | 'channel.post.edit' | 'channel.post.delete';
+export interface ChannelOperation { readonly channel: ChannelRef; readonly method: ChannelOperationMethod; readonly payload: ChannelPayload; readonly acceptedSequence?: number }
+export interface ChannelReader { read(query: ChannelReadQuery, signal?: AbortSignal): Promise<ChannelReadPage>; resolve(revision: number, signal?: AbortSignal): Promise<ChannelResolveResult> }
+const prefix = (channel: ChannelRef): string => `${channel.channelId}|`;
+const index = (number: number): string => { requireSafeInteger(number, 0); return String(number).padStart(16, '0'); };
+const channelKey = (channel: ChannelRef): RecordKey => ({ collection: 'channels', key: channel.channelId });
+const postKey = (channel: ChannelRef, sequence: number): RecordKey => ({ collection: 'channel_posts', key: `${prefix(channel)}${index(sequence)}` });
+const descriptorKey = (channel: ChannelRef, revision: number): RecordKey => ({ collection: 'channel_descriptors', key: `${prefix(channel)}${index(revision)}` });
+const eventKey = (channel: ChannelRef, sequence: number): RecordKey => ({ collection: 'channel_events', key: `${prefix(channel)}${index(sequence)}` });
+const put = (key: RecordKey, value: JsonObject): StoreMutation => ({ ...key, kind: 'put', value });
+const fingerprint = (value: JsonObject | undefined): string => canonicalJson(value ?? null);
+const sameRows = (a: readonly StoredRecord[], b: readonly StoredRecord[]): boolean => a.length === b.length && a.every((row, i) => row.key === b[i]!.key && fingerprint(row.value) === fingerprint(b[i]!.value));
+export function channelOperationKey(operation: ChannelOperation): RecordKey {
+    const target = operation.payload.kind === 'edit' || operation.payload.kind === 'delete' ? `post:${index(operation.payload.value.targetSequence)}` : 'channel';
+    return { collection: 'channel_operations', key: `${prefix(operation.channel)}${target}` };
+}
+export function encodeChannelOperation(operation: ChannelOperation): JsonObject { return { channelId: operation.channel.channelId, relayId: operation.channel.relayId, method: operation.method, payload: channelPayloadCodec.encode(operation.payload), ...(operation.acceptedSequence === undefined ? {} : { acceptedSequence: operation.acceptedSequence }) }; }
+export function readChannelOperation(row: StoredRecord): ChannelOperation {
+    const value = row.value; const channel = { channelId: String(value.channelId), relayId: String(value.relayId) }; validateChannelRef(channel);
+    const payload = channelPayloadCodec.decode(value.payload!); const method = value.method as ChannelOperationMethod;
+    const expected = payload.kind === 'descriptor' ? ['channel.create', 'channel.update', 'channel.close'] : payload.kind === 'post' ? ['channel.post'] : [`channel.post.${payload.kind}`];
+    if (value.acceptedSequence !== undefined) { requireSafeInteger(value.acceptedSequence, 1); if (method !== 'channel.post') throw new ProtocolError('invalid_storage', 'Only a publication has an accepted sequence.'); }
+    const result = { channel, method, payload, ...(value.acceptedSequence === undefined ? {} : { acceptedSequence: value.acceptedSequence }) };
+    if (!expected.includes(method) || payload.value.channelId !== channel.channelId || channelOperationKey(result).key !== row.key) throw new ProtocolError('invalid_storage', 'Stored channel operation has inconsistent method or resource binding.');
+    return result;
+}
+function decodeChannel(value: JsonObject | undefined, channel: ChannelRef): ChannelRecord {
+    if (!value) return { channel, syncSequence: -1, isFollowed: false };
+    if (value.relayId !== channel.relayId || typeof value.isFollowed !== 'boolean') throw new ProtocolError('invalid_binding', 'Stored channel belongs to another relay or is malformed.');
+    requireSafeInteger(value.syncSequence, -1);
+    return { channel, syncSequence: value.syncSequence, isFollowed: value.isFollowed, ...(value.descriptor ? { descriptor: channelDescriptorCodec.decode(value.descriptor) } : {}) };
+}
+function encodeChannel(value: ChannelRecord): JsonObject { return { relayId: value.channel.relayId, syncSequence: value.syncSequence, isFollowed: value.isFollowed, ...(value.descriptor ? { descriptor: channelDescriptorCodec.encode(value.descriptor) } : {}) }; }
+function channelInfo(value: ChannelRecord): ChannelInfo { return { ref: value.channel, isFollowed: value.isFollowed, ...(value.descriptor ? { descriptor: value.descriptor } : {}) }; }
+function decodePost(value: JsonObject): PostRecord {
+    requireSafeInteger(value.sequence, 1); requireSafeInteger(value.appliedThrough, 0);
+    if (typeof value.isDeleted !== 'boolean') throw new ProtocolError('invalid_storage', 'Malformed channel post deletion marker.');
+    if (value.acceptedAt !== undefined) requireSafeInteger(value.acceptedAt, 0);
+    return { sequence: value.sequence, appliedThrough: value.appliedThrough, isDeleted: value.isDeleted,
+        ...(value.messageId === undefined ? {} : { messageId: String(value.messageId), author: String(value.author), acceptedAt: value.acceptedAt as number }),
+        ...(value.original ? { original: channelPostCodec.decode(value.original) } : {}), ...(value.post ? { post: channelPostCodec.decode(value.post) } : {}) };
+}
+function encodePost(value: PostRecord): JsonObject { return { sequence: value.sequence, appliedThrough: value.appliedThrough, isDeleted: value.isDeleted,
+    ...(value.messageId === undefined ? {} : { messageId: value.messageId, author: value.author!, acceptedAt: value.acceptedAt! }),
+    ...(value.original ? { original: channelPostCodec.encode(value.original) } : {}), ...(value.post ? { post: channelPostCodec.encode(value.post) } : {}) }; }
+function postInfo(record: PostRecord, channel: ChannelRef): ChannelPostInfo | undefined {
+    if (record.isDeleted || !record.post) return undefined;
+    if (!record.messageId || !record.author || record.acceptedAt === undefined) throw new ProtocolError('invalid_storage', 'Visible post lacks its original publication metadata.');
+    return { ref: { channel, sequence: record.sequence }, messageId: record.messageId, author: record.author, acceptedAt: record.acceptedAt,
+        ...(record.post.body ? { body: record.post.body } : {}), ...(record.post.attachments ? { attachments: record.post.attachments } : {}) };
+}
+function target(event: ChannelEvent): number | undefined { return event.payload.kind === 'post' ? event.sequence : event.payload.kind === 'edit' || event.payload.kind === 'delete' ? event.payload.value.targetSequence : undefined; }
+function storeDescriptor(record: ChannelRecord, result: ChannelResolveResult, known: Map<number, ChannelResolveResult>): ChannelRecord {
+    const next = result.descriptor; const old = known.get(next.revision);
+    if (old && channelDescriptorCodec.stringify(old.descriptor) !== channelDescriptorCodec.stringify(next)) throw new ProtocolError('conflicting_revision', 'Channel descriptor conflicts with an already verified revision.');
+    const previous = record.descriptor;
+    if (previous && (previous.creator !== next.creator || previous.createdAt !== next.createdAt || canonicalJson([...previous.nonce]) !== canonicalJson([...next.nonce]))) throw new ProtocolError('immutable_field', 'Immutable channel fields changed.');
+    if (previous?.status === 'closed' && next.revision > previous.revision) throw new ProtocolError('closed_channel', 'A closed channel cannot have a later descriptor revision.');
+    known.set(next.revision, result); return previous && next.revision <= previous.revision ? record : { ...record, descriptor: next };
+}
+
+/** Verified evidence and projections commit together; all network reads occur before the CAS transaction. */
+export class ChannelRepository {
+    constructor(readonly store: MeshlineStore, readonly context: NetworkContext, readonly accountId: string) {}
+    async get(channel: ChannelRef, signal?: AbortSignal): Promise<ChannelRecord> { validateChannelRef(channel); return decodeChannel((await this.store.read([channelKey(channel)], signal)).sets[0]![0]?.value, channel); }
+    async post(post: ChannelPostRef, signal?: AbortSignal): Promise<ChannelPostInfo | undefined> {
+        validateChannelPostRef(post); const rows = await this.store.read([channelKey(post.channel), postKey(post.channel, post.sequence)], signal); decodeChannel(rows.sets[0]![0]?.value, post.channel);
+        const row = rows.sets[1]![0]; return row && postInfo(decodePost(row.value), post.channel);
+    }
+    async posts(channelId?: string, author?: string, signal?: AbortSignal): Promise<QueryReader<ChannelPostInfo>> {
+        const rows = await this.store.read([{ collection: 'channel_posts', ...(channelId ? { prefix: `${channelId}|` } : {}) }, { collection: 'channels' }], signal);
+        const channels = new Map(rows.sets[1]!.map(row => [row.key, { channelId: row.key, relayId: String(row.value.relayId) }]));
+        const values = rows.sets[0]!.map(row => postInfo(decodePost(row.value), channels.get(row.key.split('|')[0]!)!)).filter((value): value is ChannelPostInfo => value !== undefined && (author === undefined || value.author === author));
+        return snapshotReader(values);
+    }
+    async followed(relayId?: string, signal?: AbortSignal): Promise<readonly ChannelRecord[]> {
+        const rows = (await this.store.read([{ collection: 'channels' }], signal)).sets[0]!;
+        return rows.filter(row => row.value.isFollowed && (relayId === undefined || row.value.relayId === relayId)).map(row => decodeChannel(row.value, { channelId: row.key, relayId: String(row.value.relayId) }));
+    }
+    async follow(channel: ChannelRef, followed: boolean, signal?: AbortSignal): Promise<boolean> {
+        return updateStore(this.store, [channelKey(channel)], snapshot => {
+            const row = snapshot.sets[0]![0]; if (!row) return { mutations: [], result: false }; const current = decodeChannel(row.value, channel);
+            return { mutations: current.isFollowed === followed ? [] : [put(channelKey(channel), encodeChannel({ ...current, isFollowed: followed }))], result: current.isFollowed !== followed };
+        }, signal);
+    }
+    async saveDescriptor(channel: ChannelRef, result: ChannelResolveResult, operation?: ChannelOperation, signal?: AbortSignal): Promise<ChannelInfo | undefined> {
+        verifyChannelDescriptor(result, this.context, channel); const key = descriptorKey(channel, result.descriptor.revision);
+        return updateStore(this.store, [channelKey(channel), key, ...(operation ? [channelOperationKey(operation)] : [])], snapshot => {
+            const before = decodeChannel(snapshot.sets[0]![0]?.value, channel); const known = new Map<number, ChannelResolveResult>();
+            if (snapshot.sets[1]![0]) known.set(result.descriptor.revision, channelResolveResultCodec.decode(snapshot.sets[1]![0]!.value));
+            const current = storeDescriptor(before, result, known); const mutations = [put(channelKey(channel), encodeChannel(current)), put(key, channelResolveResultCodec.encode(result))];
+            if (operation && fingerprint(snapshot.sets[2]![0]?.value) === canonicalJson(encodeChannelOperation(operation))) mutations.push({ kind: 'delete', ...channelOperationKey(operation) });
+            return { mutations, result: current !== before ? channelInfo(current) : undefined };
+        }, signal);
+    }
+    async saveOperation(operation: ChannelOperation, signal?: AbortSignal): Promise<void> {
+        validateChannelRef(operation.channel); validateChannelPayload(operation.payload, this.context); const key = channelOperationKey(operation);
+        await updateStore(this.store, [key], snapshot => {
+            if (snapshot.sets[0]!.length) throw new StateConflictError('An earlier operation on this channel resource remains unfinished. Start the component to recover it.');
+            return { mutations: [put(key, encodeChannelOperation(operation))], result: undefined };
+        }, signal);
+    }
+    async operations(signal?: AbortSignal): Promise<readonly ChannelOperation[]> { return (await this.store.read([{ collection: 'channel_operations' }], signal)).sets[0]!.map(readChannelOperation); }
+    async hasOperation(operation: ChannelOperation, signal?: AbortSignal): Promise<boolean> { return fingerprint((await this.store.read([channelOperationKey(operation)], signal)).sets[0]![0]?.value) === canonicalJson(encodeChannelOperation(operation)); }
+    async acknowledgePublication(operation: ChannelOperation, sequence: number): Promise<ChannelOperation> {
+        requireSafeInteger(sequence, 1); if (operation.method !== 'channel.post') throw new ProtocolError('invalid_operation', 'Only publications return sequence acknowledgements.');
+        const accepted = { ...operation, acceptedSequence: sequence }; const key = channelOperationKey(operation);
+        await updateStore(this.store, [key], snapshot => {
+            if (fingerprint(snapshot.sets[0]![0]?.value) !== canonicalJson(encodeChannelOperation(operation))) throw new StateConflictError('Publication changed before acknowledgement could be saved.');
+            return { mutations: [put(key, encodeChannelOperation(accepted))], result: undefined };
+        }); return accepted;
+    }
+    async confirmPublication(channel: ChannelRef, sequence: number, request: ChannelPost, signal?: AbortSignal): Promise<void> {
+        const value = (await this.store.read([postKey(channel, sequence)], signal)).sets[0]![0]?.value;
+        if (!value) throw new ProtocolError('missing_publication', 'Accepted publication is absent from the verified timeline.'); const post = decodePost(value);
+        if (post.messageId !== undefined && (post.messageId !== request.messageId || post.author !== this.accountId || post.original && channelPostCodec.stringify(post.original) !== channelPostCodec.stringify(request))) throw new ProtocolError('conflicting_publication', 'Acknowledged sequence identifies another publication.');
+    }
+    async completeOperation(operation: ChannelOperation, deletion = false, signal?: AbortSignal): Promise<ChannelPostChange | undefined> {
+        const channel = operation.channel; const sequence = deletion && operation.payload.kind === 'delete' ? operation.payload.value.targetSequence : undefined;
+        return updateStore(this.store, [channelOperationKey(operation), channelKey(channel), ...(sequence ? [postKey(channel, sequence)] : [])], snapshot => {
+            const mutations: StoreMutation[] = []; let result: ChannelPostChange | undefined;
+            if (fingerprint(snapshot.sets[0]![0]?.value) !== canonicalJson(encodeChannelOperation(operation))) return { mutations, result };
+            mutations.push({ kind: 'delete', ...channelOperationKey(operation) }, put(channelKey(channel), encodeChannel(decodeChannel(snapshot.sets[1]![0]?.value, channel))));
+            if (sequence !== undefined) {
+                const previous = snapshot.sets[2]![0]?.value; const post = previous ? decodePost(previous) : { sequence, appliedThrough: sequence, isDeleted: false };
+                if (!post.isDeleted && post.post) result = { ref: { channel, sequence }, kind: 'deleted' };
+                post.isDeleted = true; delete post.post; mutations.push(put(postKey(channel, sequence), encodePost(post)));
+            }
+            return { mutations, result };
+        }, signal);
+    }
+    async publication(channel: ChannelRef, request: ChannelPost, signal?: AbortSignal): Promise<number | undefined> {
+        const rows = (await this.store.read([{ collection: 'channel_posts', prefix: prefix(channel) }], signal)).sets[0]!;
+        const post = rows.map(row => decodePost(row.value)).find(value => value.messageId === request.messageId && value.author === this.accountId);
+        if (post?.original && channelPostCodec.stringify(post.original) !== channelPostCodec.stringify(request)) throw new ProtocolError('conflicting_publication', 'Synchronized publication differs from the exact pending request.'); return post?.sequence;
+    }
+    async readPage(channel: ChannelRef, query: ChannelReadQuery, reader: ChannelReader, advance: boolean, signal?: AbortSignal): Promise<{ page: ChannelReadPage; changes: ChannelChanges }> {
+        validateChannelRef(channel); validateChannelReadQuery(query); if (query.channelId !== channel.channelId) throw new ProtocolError('invalid_binding', 'History query belongs to another channel.');
+        const queries: RecordQuery[] = [channelKey(channel), ...['channel_posts', 'channel_descriptors', 'channel_events', 'channel_operations'].map(collection => ({ collection, prefix: prefix(channel) }))];
+        const snapshot = await this.store.read(queries, signal); let record = decodeChannel(snapshot.sets[0]![0]?.value, channel); const beforeChannel = record;
+        const known = new Map(snapshot.sets[2]!.map(row => { const result = channelResolveResultCodec.decode(row.value); verifyChannelDescriptor(result, this.context, channel); return [result.descriptor.revision, result] as const; }));
+        const descriptors = new Map<number, ChannelResolveResult>(); const evidence = new Map<number, { event: ChannelEvent; certificate: DeviceCertificate }>();
+        const applied = new Set<number>();
+        const read = async (selection: ChannelReadQuery): Promise<ChannelReadPage> => {
+            const page = channelReadPageCodec.decode(channelReadPageCodec.encode(await reader.read(selection, signal))); const certificates = validateChannelReadPage(page, selection, this.context);
+            for (const entry of page.events) if (entry.payload.kind === 'descriptor') {
+                const resolved = { descriptor: entry.payload.value, signerCertificate: certificates.get(entry.signerDeviceId)! }; verifyChannelDescriptor(resolved, this.context, channel);
+                const previous = descriptors.get(entry.descriptorRev) ?? known.get(entry.descriptorRev);
+                if (previous && channelDescriptorCodec.stringify(previous.descriptor) !== channelDescriptorCodec.stringify(resolved.descriptor)) throw new ProtocolError('conflicting_revision', 'Timeline descriptor conflicts with verified evidence.'); descriptors.set(entry.descriptorRev, resolved);
+            }
+            for (const entry of page.events) {
+                let resolved = descriptors.get(entry.descriptorRev) ?? known.get(entry.descriptorRev);
+                if (!resolved) { resolved = await reader.resolve(entry.descriptorRev, signal); verifyChannelDescriptor(resolved, this.context, channel); if (resolved.descriptor.revision !== entry.descriptorRev) throw new ProtocolError('invalid_revision', 'Relay returned a different descriptor revision.'); }
+                descriptors.set(entry.descriptorRev, resolved); const certificate = certificates.get(entry.signerDeviceId)!; verifyChannelEvent(entry, certificate, resolved.descriptor, this.context, channel);
+                const previous = evidence.get(entry.sequence)?.event ?? (snapshot.sets[3]!.find(row => row.key === eventKey(channel, entry.sequence).key)?.value.event ? channelEventCodec.decode(snapshot.sets[3]!.find(row => row.key === eventKey(channel, entry.sequence).key)!.value.event!) : undefined);
+                if (previous && channelEventCodec.stringify(previous) !== channelEventCodec.stringify(entry)) throw new ProtocolError('conflicting_event', 'Timeline sequence conflicts with previously verified evidence.'); evidence.set(entry.sequence, { event: entry, certificate });
+            }
+            return page;
+        };
+        const page = await read(query); const posts = new Map<number, PostRecord>(); const originals = new Map<number, PostRecord | undefined>();
+        const boundary = query.after ?? (page.events[0]?.sequence ?? 0) - 1;
+        for (const event of page.events) {
+            const sequence = target(event); if (sequence === undefined || posts.has(sequence)) continue;
+            const saved = snapshot.sets[1]!.find(row => row.key === postKey(channel, sequence).key)?.value; const before = saved && decodePost(saved); originals.set(sequence, before);
+            const post: PostRecord = saved ? decodePost(saved) : { sequence, appliedThrough: sequence - 1, isDeleted: false }; posts.set(sequence, post);
+            const related = page.events.filter(entry => target(entry) === sequence);
+            const deletion = related.find(entry => entry.payload.kind === 'delete');
+            if (deletion) { post.isDeleted = true; delete post.post; post.appliedThrough = Math.max(post.appliedThrough, deletion.sequence); continue; }
+            if (post.isDeleted) continue; if (post.post) post.appliedThrough = Math.max(post.appliedThrough, record.syncSequence);
+            if (related.some(entry => entry.payload.kind === 'edit' && entry.sequence > post.appliedThrough) && !related.some(entry => entry.payload.kind === 'post') && post.appliedThrough < boundary) {
+                let after = post.appliedThrough;
+                for (;;) { const caught = await read({ channelId: channel.channelId, after });
+                    for (const entry of caught.events) if (target(entry) === sequence && (entry.sequence <= boundary || entry.payload.kind === 'delete')) {
+                        this.#apply(post, entry, evidence.get(entry.sequence)!.certificate); applied.add(entry.sequence);
+                    }
+                    if (!caught.hasMore || caught.events.at(-1)!.sequence >= boundary) break; after = caught.events.at(-1)!.sequence;
+                }
+            }
+        }
+        for (const entry of page.events) { const sequence = target(entry); if (sequence !== undefined) { this.#apply(posts.get(sequence)!, entry, evidence.get(entry.sequence)!.certificate); applied.add(entry.sequence); } }
+        const changes: ChannelPostChange[] = []; const mutations: StoreMutation[] = [];
+        for (const post of posts.values()) {
+            if (!post.isDeleted && !post.post) throw new ProtocolError('missing_original', 'Original channel post is unavailable; the page remains uncommitted.');
+            post.appliedThrough = Math.max(post.appliedThrough, page.events.at(-1)!.sequence); const before = originals.get(post.sequence); const info = postInfo(post, channel);
+            if (!before?.isDeleted) { if (post.isDeleted && before?.post) changes.push({ ref: { channel, sequence: post.sequence }, kind: 'deleted' });
+                else if (info && fingerprint(before?.post && channelPostCodec.encode(before.post)) !== fingerprint(post.post && channelPostCodec.encode(post.post))) changes.push({ ref: info.ref, kind: before?.post ? 'edited' : 'added', info }); }
+            mutations.push(put(postKey(channel, post.sequence), encodePost(post)));
+        }
+        for (const result of [...descriptors.values()].sort((a, b) => a.descriptor.revision - b.descriptor.revision)) { record = storeDescriptor(record, result, known); mutations.push(put(descriptorKey(channel, result.descriptor.revision), channelResolveResultCodec.encode(result))); }
+        if (advance && page.events.length) record = { ...record, syncSequence: Math.max(record.syncSequence, page.events.at(-1)!.sequence) };
+        mutations.push(put(channelKey(channel), encodeChannel(record)));
+        for (const { event, certificate } of evidence.values()) {
+            mutations.push(put(eventKey(channel, event.sequence), { event: channelEventCodec.encode(event) }));
+            // Catch-up verifies whole pages, but may project only an earlier subset
+            // for selected posts. Confirmation must commit with the affected projection.
+            if (!applied.has(event.sequence)) continue;
+            for (const row of snapshot.sets[4]!) {
+                const operation = readChannelOperation(row); const payload = operation.payload;
+                if (payload.kind === 'post' && event.payload.kind === 'post' && payload.value.messageId === event.payload.value.messageId && certificate.account === this.accountId) {
+                    if (operation.acceptedSequence !== undefined && operation.acceptedSequence !== event.sequence) throw new ProtocolError('invalid_sequence', 'Publication acknowledgement differs from its verified timeline sequence.');
+                    if (canonicalJson(channelPayloadCodec.encode(payload)) !== canonicalJson(channelPayloadCodec.encode(event.payload))) throw new ProtocolError('conflicting_publication', 'Synchronized post conflicts with the pending publication.'); mutations.push({ ...channelOperationKey(operation), kind: 'delete' });
+                } else if ((payload.kind === 'edit' || payload.kind === 'delete') && payload.kind === event.payload.kind && target(event) === payload.value.targetSequence
+                    && (payload.kind === 'delete' || canonicalJson(channelPayloadCodec.encode(payload)) === canonicalJson(channelPayloadCodec.encode(event.payload)))) mutations.push({ ...channelOperationKey(operation), kind: 'delete' });
+            }
+        }
+        const unique = [...new Map(mutations.map(mutation => [`${mutation.collection}|${mutation.key}`, mutation])).values()];
+        await updateStore(this.store, queries, current => {
+            if (snapshot.sets.some((rows, i) => !sameRows(rows, current.sets[i]!))) throw new StateConflictError('Channel state changed while history was being verified; retry with current state.');
+            return { mutations: unique, result: undefined };
+        }, signal);
+        return { page, changes: { posts: changes, ...(record.descriptor !== beforeChannel.descriptor ? { channel: channelInfo(record) } : {}) } };
+    }
+    #apply(post: PostRecord, entry: ChannelEvent, certificate: DeviceCertificate): void {
+        const payload = entry.payload;
+        if (payload.kind === 'post') {
+            if (post.messageId !== undefined) { if (post.messageId !== payload.value.messageId || post.author !== certificate.account || post.original && channelPostCodec.stringify(post.original) !== channelPostCodec.stringify(payload.value)) throw new ProtocolError('conflicting_post', 'Original channel publication changed.'); return; }
+            post.messageId = payload.value.messageId; post.author = certificate.account; post.acceptedAt = entry.acceptedAt; post.original = payload.value; if (!post.isDeleted) post.post = payload.value;
+        } else if (payload.kind === 'delete') { post.isDeleted = true; delete post.post; }
+        else if (payload.kind === 'edit' && !post.isDeleted && entry.sequence > post.appliedThrough) {
+            if (!post.post) throw new ProtocolError('missing_original', 'Original channel post is unavailable; the page remains uncommitted.'); post.post = applyChannelPostEdit(post.post, payload.value);
+        }
+        post.appliedThrough = Math.max(post.appliedThrough, entry.sequence);
+    }
+}