@astrosheep/square 0.3.106 → 0.4.1

package/dist/sqlite-values.d.ts

@@ -0,0 +1,21 @@
+import { SquareError, type FactPage, type IndexPage } from './neutral.js';
+export type Row = Record<string, string | number | null>;
+export declare const encode: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export declare const key: (name: string) => string;
+export declare function invalidArtifact(detail: string): SquareError;
+export declare function requireFact(ok: unknown, detail?: string): asserts ok;
+export declare function integer(value: unknown, minimum?: number): number;
+export declare function finite(value: unknown): number;
+export declare function string(value: unknown, nonempty?: boolean): string;
+export declare function json(value: unknown): unknown;
+export declare function object(value: unknown): Record<string, unknown>;
+export declare function shape(value: unknown, required: readonly string[], optional?: readonly string[]): Record<string, unknown>;
+export declare function strings(value: unknown): string[];
+export declare function decoded(value: unknown, nonempty?: boolean): string;
+export declare function immutable<T>(value: T): T;
+export declare function stableJson(value: unknown): string;
+export declare function pageRows<T>(rows: Row[], page: IndexPage, decode: (row: Row) => T): FactPage<T>;
+export declare function pageLimit(page: IndexPage): number;

package/dist/sqlite-values.js

@@ -0,0 +1,78 @@
+import { SquareError, nameKey } from './neutral.js';
+export const encode = JSON.stringify;
+export const key = (name) => encode(nameKey(name));
+export function invalidArtifact(detail) {
+    return new SquareError('invalid_args', `Invalid square artifact: ${detail}`);
+}
+export function requireFact(ok, detail = 'row is malformed.') {
+    if (!ok)
+        throw invalidArtifact(detail);
+}
+export function integer(value, minimum = 0) {
+    requireFact(Number.isSafeInteger(value) && value >= minimum);
+    return value;
+}
+export function finite(value) {
+    requireFact(typeof value === 'number' && Number.isFinite(value));
+    return value;
+}
+export function string(value, nonempty = false) {
+    requireFact(typeof value === 'string' && (!nonempty || value.length > 0));
+    return value;
+}
+export function json(value) {
+    try {
+        return JSON.parse(string(value));
+    }
+    catch {
+        throw invalidArtifact('row contains invalid JSON.');
+    }
+}
+export function object(value) {
+    requireFact(typeof value === 'object' && value !== null && !Array.isArray(value));
+    return value;
+}
+export function shape(value, required, optional = []) {
+    const result = object(value);
+    requireFact(required.every(k => Object.hasOwn(result, k)) && Object.keys(result).every(k => required.includes(k) || optional.includes(k)));
+    return result;
+}
+export function strings(value) {
+    requireFact(Array.isArray(value) && value.every(v => typeof v === 'string'));
+    return value;
+}
+export function decoded(value, nonempty = false) {
+    const result = string(json(value), nonempty);
+    requireFact(encode(result) === value, 'string encoding is malformed.');
+    return result;
+}
+export function immutable(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const item of Object.values(value))
+            immutable(item);
+        Object.freeze(value);
+    }
+    return value;
+}
+// Sorted object keys express small-value structural equality, never whole-state comparison.
+export function stableJson(value) {
+    if (value === null || typeof value !== 'object') {
+        requireFact(value === null || typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value), 'value contains a non-finite or unsupported JSON value.');
+        return encode(value);
+    }
+    if (Array.isArray(value))
+        return '[' + value.map(stableJson).join(',') + ']';
+    return '{' + Object.keys(value).sort().map(k => encode(k) + ':' + stableJson(value[k])).join(',') + '}';
+}
+export function pageRows(rows, page, decode) {
+    const hasMore = rows.length > page.limit;
+    if (hasMore)
+        rows.pop();
+    if (page.edge === 'newest')
+        rows.reverse();
+    return immutable({ items: rows.map(decode), hasMore });
+}
+export function pageLimit(page) {
+    requireFact(page.edge === 'oldest' || page.edge === 'newest');
+    return Math.min(integer(page.limit, 1) + 1, Number.MAX_SAFE_INTEGER);
+}

package/dist/square-api.d.ts

@@ -16,4 +16,4 @@ export declare function selectOwnSeat(square: Pick<SqliteSquare, 'participant' |
 }): Promise<Participant | undefined>;
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';
+export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-api.js

@@ -1,12 +1,8 @@
 import { SqliteSquare } from './sqlite-square.js';
 import { SquareError } from './model.js';
 import { requireOwner } from './seats.js';
-import { createDefaultWakeTransport } from './notifications.js';
-export const Square = { at: async (input, control) => SqliteSquare.at({ ...input, wakeTransport: await resolveWakeTransport(input) }, control),
-    build: async (input, control) => SqliteSquare.build({ ...input, wakeTransport: await resolveWakeTransport(input) }, control), inMemory: SqliteSquare.inMemory };
-const resolveWakeTransport = (input) => input.wakeTransport !== undefined
-    ? Promise.resolve(input.wakeTransport)
-    : createDefaultWakeTransport(input.env ?? process.env).catch(() => undefined);
+export const Square = { at: (input, control) => SqliteSquare.at(input, control),
+    build: (input, control) => SqliteSquare.build(input, control), inMemory: SqliteSquare.inMemory };
 export { requireOwner, requireJoinName } from './seats.js';
 export { squareLocation } from './square-location.js';
 export async function selectOwnSeat(square, owner, name, options) {
@@ -15,7 +11,8 @@ export async function selectOwnSeat(square, owner, name, options) {
     const caller = requireOwner(owner);
     if (name !== undefined)
         return square.participant(name, { owner: caller });
-    const seats = (await square.seatsOf(caller)).filter(seat => seat.attachment === 'attached');
+    // Selection is local producer custody, not a ledger attachment check.
+    const seats = await square.seatsOf(caller);
     if (seats.length !== 1) {
         if (options?.optional)
             return undefined;
@@ -27,4 +24,4 @@ export async function selectOwnSeat(square, owner, name, options) {
 }
 export { ACTIVITY_METADATA_MAX_BYTES } from './model.js';
 export { localUserOwner, harnessOwner, decodeHarnessOwner } from './owner.js';
-export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, migrateSquare, discover, inbox } from './sqlite-square.js';
+export { squareClock, createSquareResourceOwner, formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT, diagnoseSquare, discover, inbox } from './sqlite-square.js';

package/dist/square-core.d.ts

@@ -26,7 +26,6 @@ export type Act = {
     at?: number;
     body?: string;
     metadata?: import('./model.js').ActivityMetadata;
-    delivery?: import('./model.js').ActivityDelivery;
     mentions?: readonly Participant[];
     reach?: Reach;
     reply?: number;

package/dist/square-domain.d.ts

@@ -1,7 +1,10 @@
-import { type Seat, type StoredAct } from './model.js';
+import { type ActDraft, type Seat } from './model.js';
 import type { ArtifactWriteAuthority, AttentionFact, LandedRecipient, ParticipantFact, SeatRef, SquareRead, SquareWrite } from './ports.js';
+import type { ProducerWrite } from './square-post.js';
 export interface LandingEffect {
-    readonly activity: StoredAct;
+    readonly activity: ActDraft & {
+        readonly index: number;
+    };
     readonly participant?: ParticipantFact;
     readonly removeListeningOf?: string;
     readonly removeListening?: {
@@ -14,24 +17,23 @@ export interface LandingEffect {
 export interface LandingFacts {
     readonly actor?: ParticipantFact;
     readonly standing: readonly ParticipantFact[];
+    readonly seats: ReadonlyMap<string, Seat>;
     readonly incoming: readonly AttentionFact[];
     readonly outgoing: readonly AttentionFact[];
     readonly replyAuthor?: string;
 }
-/** The single landing transition, shared by both adapters and explicit rebuild. */
-export declare function deriveLanding(activity: StoredAct, facts: LandingFacts): LandingEffect;
-export declare function landingFacts(read: SquareRead, activity: StoredAct): LandingFacts;
-export interface LandingWriter extends Pick<SquareWrite, 'markSeen' | 'putLease' | 'removeLease' | 'updateWakeAddress' | 'reattachSeat' | 'detachSeat' | 'cancelThrough' | 'putDeliveryDeferral' | 'renewDeliveryDeferral' | 'releaseDeliveryDeferral' | 'claimDelivery' | 'prepareDelivery' | 'completeDelivery' | 'observeNativeDelivery'> {
-    /** Artifact-private seat persistence used only by this gate's lifecycle transition. */
+export declare function deriveLanding(activity: ActDraft & {
+    readonly index: number;
+}, facts: LandingFacts): LandingEffect;
+export declare function landingFacts(read: SquareRead, activity: ActDraft): LandingFacts;
+export interface LandingWriter extends Pick<SquareWrite, 'putLease' | 'removeLease' | 'markSeen' | 'setSeatAttachment'>, ProducerWrite {
     storeSeat(seat: Seat): boolean;
-    removeSeat(seat: import('./ports.js').SeatRef): boolean;
+    removeSeat(seat: SeatRef): boolean;
     applyLanding(effect: LandingEffect): void;
 }
 export interface SquareWriteGate {
     readonly facts: SquareWrite;
     complete(): void;
 }
-/** Read probes and writes share the same captured-coordinate and attachment fence. */
 export declare function assertCurrentSeat(read: SquareRead, expected: SeatRef, allowDetached?: boolean): void;
-/** The artifact transaction supplies one captured authority; every mutation checks it here. */
 export declare function wrapSquareWrite(read: SquareRead, writes: LandingWriter, authority: ArtifactWriteAuthority): SquareWriteGate;

package/dist/square-domain.js

@@ -1,61 +1,47 @@
-import { SquareError, formatActivityId, parseActivityId, sameName, validateActivityDelivery, validateOwner, validateName } from './model.js';
+import { SquareError, nameKey, sameName, validateOwner, validateName } from './model.js';
+import { newEndpointGeneration, validateEndpointGeneration } from './message.js';
 import { resolveAudience } from './attention.js';
-/** The single landing transition, shared by both adapters and explicit rebuild. */
+import { freshWatchLease } from './runtime.js';
+import { leaseOwnsNotification } from './catch-selection.js';
 export function deriveLanding(activity, facts) {
-    if (activity.kind === 'say' && activity.delivery?.mode === 'direct') {
-        const audience = [];
-        for (const mention of activity.mentions ?? []) {
-            const recipient = facts.standing.find(item => sameName(item.name, mention))?.name;
-            if (recipient !== undefined && !audience.some(item => sameName(item.recipient, recipient)))
-                audience.push({ recipient, route: 'mention' });
-        }
-        return { activity, audience };
-    }
     const audience = activity.kind === 'say' ? resolveAudience({
-        actor: activity.actor, recipients: facts.standing.map((item) => item.name),
-        mentions: activity.mentions, replyAuthor: facts.replyAuthor, reach: activity.reach,
-        incoming: facts.incoming, sameIdentity: sameName,
+        actor: activity.actor, recipients: facts.standing.map(item => item.name), mentions: activity.mentions,
+        replyAuthor: facts.replyAuthor, reach: activity.reach, incoming: facts.incoming, sameIdentity: sameName,
+    }).map(recipient => {
+        const seat = facts.seats.get(nameKey(recipient.recipient));
+        return { ...recipient, ...(seat === undefined ? {} : { generation: seat.generation, owner: seat.owner }) };
     }) : [];
-    const actor = activity.actor;
-    const previous = facts.actor ?? { name: actor, firstIndex: activity.index, joined: false, done: false, sayCount: 0 };
+    const previous = facts.actor ?? { name: activity.actor, firstIndex: activity.index, joined: false, done: false, sayCount: 0 };
     const participant = {
-        ...previous,
-        lastActiveAt: Math.max(previous.lastActiveAt ?? -Infinity, activity.at),
+        ...previous, lastActiveAt: Math.max(previous.lastActiveAt ?? -Infinity, activity.at),
         ...(activity.kind === 'join' ? { joined: true, done: false, lastJoinIndex: activity.index } : {}),
         ...(activity.kind === 'done' ? { joined: false, done: true } : {}),
         ...(activity.kind === 'say' ? { sayCount: previous.sayCount + 1 } : {}),
     };
     let replaceAttention;
     if (activity.kind === 'listen' || activity.kind === 'ignore') {
-        const existing = facts.outgoing.find((item) => sameName(item.target, activity.target));
-        if (existing?.kind !== activity.kind) {
+        const existing = facts.outgoing.find(item => sameName(item.target, activity.target));
+        if (existing?.kind !== activity.kind)
             replaceAttention = { listener: participant.name, target: activity.target, kind: activity.kind, sinceIndex: activity.index };
-        }
     }
-    const removeListening = activity.kind === 'unlisten'
-        && facts.outgoing.some((item) => item.kind === 'listen' && sameName(item.target, activity.target))
+    const removeListening = activity.kind === 'unlisten' && facts.outgoing.some(item => item.kind === 'listen' && sameName(item.target, activity.target))
         ? { listener: participant.name, target: activity.target } : undefined;
-    return {
-        activity, participant, audience,
-        ...(activity.kind === 'done' ? { removeListeningOf: participant.name } : {}),
-        ...(removeListening === undefined ? {} : { removeListening }),
-        ...(replaceAttention === undefined ? {} : { replaceAttention }),
-    };
+    return { activity, participant, audience, ...(activity.kind === 'done' ? { removeListeningOf: participant.name } : {}),
+        ...(removeListening === undefined ? {} : { removeListening }), ...(replaceAttention === undefined ? {} : { replaceAttention }) };
 }
 export function landingFacts(read, activity) {
-    return {
-        actor: read.participant(activity.actor),
-        standing: activity.kind === 'say' ? read.roster().filter((item) => item.joined) : [],
+    const standing = activity.kind === 'say' ? read.roster().filter(item => item.joined) : [];
+    const seats = new Map();
+    for (const participant of standing) {
+        const seat = read.seat(participant.name);
+        if (seat !== undefined)
+            seats.set(nameKey(participant.name), seat);
+    }
+    return { actor: read.participant(activity.actor), standing, seats,
         incoming: activity.kind === 'say' ? read.incomingAttention(activity.actor) : [],
         outgoing: activity.kind === 'listen' || activity.kind === 'ignore' || activity.kind === 'unlisten' ? read.attention(activity.actor) : [],
-        replyAuthor: activity.kind === 'say' && activity.reply !== undefined ? read.activity(activity.reply)?.actor : undefined,
-    };
-}
-function validateGeneration(value) {
-    if (typeof value !== 'string' || parseActivityId(value) === undefined)
-        throw new SquareError('invalid_args', 'Artifact authority requires a valid join generation.');
+        replyAuthor: activity.kind === 'say' && activity.reply !== undefined ? read.activity(activity.reply)?.actor : undefined };
 }
-/** Read probes and writes share the same captured-coordinate and attachment fence. */
 export function assertCurrentSeat(read, expected, allowDetached = false) {
     const current = read.seat(expected.participant);
     if (current === undefined || current.owner !== expected.owner || current.generation !== expected.generation)
@@ -63,234 +49,130 @@ export function assertCurrentSeat(read, expected, allowDetached = false) {
     if (!allowDetached && current.attachment !== 'attached')
         throw new SquareError('already_joined', 'This participant is away; join again before writing.', { reason: 'needs_seat', activityUnsent: true });
 }
-/** The artifact transaction supplies one captured authority; every mutation checks it here. */
 export function wrapSquareWrite(read, writes, authority) {
-    if (authority === undefined || typeof authority !== 'object' || authority === null)
+    if (!authority || typeof authority !== 'object')
         throw new SquareError('invalid_args', 'Artifact writes require an explicit authority.');
-    const { applyLanding, ...mutations } = writes;
+    const denied = () => { throw new SquareError('invalid_args', 'This authority cannot perform that write.'); };
+    const deniedWrites = { land: denied, putLease: denied, removeLease: denied, markSeen: denied, setSeatAttachment: denied, insertNotice: denied, ackMatching: denied, acquirePost: denied, settlePost: denied, foldReceipt: denied };
+    if (authority.kind === 'producer') {
+        return { facts: Object.assign({}, read, deniedWrites, {
+                acquirePost(post, token, pid, now, exportAt) {
+                    if (post.kind === 'activity') {
+                        const lease = freshWatchLease(read, post.recipient, now);
+                        const arrival = read.directedAt(post.recipient, post.index);
+                        if (lease && arrival?.generation === post.generation && leaseOwnsNotification(lease, arrival))
+                            return false;
+                    }
+                    return writes.acquirePost(post, token, pid, now, exportAt);
+                },
+                settlePost: writes.settlePost, foldReceipt: writes.foldReceipt, setSeatAttachment: writes.setSeatAttachment,
+            }), complete() { } };
+    }
+    if (authority.kind === 'send') {
+        validateName(authority.actor);
+        return { facts: Object.assign({}, read, deniedWrites, { insertNotice(input, at) {
+                    if (!sameName(input.from, authority.actor))
+                        throw new SquareError('invalid_args', 'Notice sender does not match its authority.');
+                    return writes.insertNotice(input, at);
+                } }), complete() { } };
+    }
     const seated = authority.kind === 'participant' || authority.kind === 'host-cleanup';
-    const expectedName = seated ? authority.seat?.participant : authority.kind === 'send' ? authority.actor : authority.participant;
-    if (!['participant', 'host-cleanup', 'join', 'takeover', 'send'].includes(authority.kind) || typeof expectedName !== 'string')
-        throw new SquareError('invalid_args', 'Artifact write authority is malformed.');
-    validateName(expectedName);
+    const name = seated ? authority.seat.participant : authority.participant;
+    validateName(name);
     if (seated) {
         validateOwner(authority.seat.owner);
-        validateGeneration(authority.seat.generation);
+        validateEndpointGeneration(authority.seat.generation);
     }
-    else if (authority.kind !== 'send') {
+    else {
         validateOwner(authority.owner);
         if (authority.kind === 'takeover')
-            validateGeneration(authority.expectedGeneration);
+            validateEndpointGeneration(authority.expectedGeneration);
     }
-    const assertSeat = (seat, expected = authority.kind === 'participant' ? authority.seat : undefined, allowDetached = false) => {
-        if (expected === undefined || !sameName(expected.participant, seat.participant)
-            || seat.generation !== expected.generation || seat.owner !== expected.owner)
-            throw new SquareError('already_joined', 'This write needs the current participant seat.');
-        assertCurrentSeat(read, expected, allowDetached);
-    };
-    const assertParticipant = (name, generation) => {
-        if (authority.kind !== 'participant')
+    if (authority.kind === 'participant')
+        assertCurrentSeat(read, authority.seat);
+    if (authority.kind === 'join' && read.participant(name)?.joined) {
+        const seat = read.seat(name);
+        if (seat === undefined || seat.owner !== authority.owner)
+            throw new SquareError('already_joined', `${name} is held by another owner; take it over explicitly`);
+    }
+    if (authority.kind === 'takeover' && read.seat(name)?.generation !== authority.expectedGeneration)
+        throw new SquareError('already_joined', 'The participant seat changed before takeover.');
+    let takeoverPhase = 'ready';
+    let establishedSeat;
+    const participant = (requested, generation) => {
+        if (authority.kind !== 'participant' || !sameName(requested, name) || generation !== undefined && generation !== authority.seat.generation)
             throw new SquareError('already_joined', 'This write needs the current participant seat.');
-        assertSeat({ ...authority.seat, participant: name, generation: generation === undefined ? authority.seat.generation : generation });
+        assertCurrentSeat(read, authority.seat);
     };
-    let reconnectSeat;
-    let takeoverPhase = authority.kind === 'takeover' ? 'ready' : undefined;
-    if (authority.kind === 'participant') {
-        assertSeat(authority.seat);
-    }
-    else if (authority.kind === 'host-cleanup') {
-        // A late host cleanup is allowed to inspect a stale coordinate and return a no-op.
-    }
-    else if (authority.kind === 'join') {
-        const participant = read.participant(expectedName), seat = read.seat(expectedName);
-        if (participant?.joined) {
-            if (seat === undefined || seat.owner !== authority.owner)
-                throw new SquareError('already_joined', `${expectedName} is held by another owner; take it over explicitly`);
-            reconnectSeat = seat;
-        }
-    }
-    else if (authority.kind === 'takeover') {
-        const current = read.seat(expectedName);
-        if (current === undefined || current.generation !== authority.expectedGeneration)
-            throw new SquareError('already_joined', 'The participant seat changed before takeover.');
-    }
-    let lastActivity;
-    const facts = Object.assign({}, read, {
+    const facts = Object.assign({}, read, deniedWrites, {
         land(activity) {
-            const actor = 'actor' in activity ? activity.actor : undefined;
-            if (actor === undefined)
-                throw new SquareError('invalid_args', 'Participant activities require a named actor.');
-            validateName(actor);
-            if (!sameName(actor, expectedName))
+            if (!sameName(activity.actor, name))
                 throw new SquareError('already_joined', 'Activity actor does not match the artifact authority.');
-            if (activity.kind === 'say')
-                validateActivityDelivery(activity.delivery);
-            if (authority.kind === 'send') {
-                if (activity.kind !== 'say' || activity.delivery?.mode !== 'direct' || activity.reach !== undefined || activity.reply !== undefined)
-                    throw new SquareError('invalid_args', 'Send authority may only land direct messages without bell or reply.');
-            }
-            else if (authority.kind === 'participant') {
-                assertSeat(authority.seat);
+            if (authority.kind === 'participant') {
+                assertCurrentSeat(read, authority.seat);
                 if (activity.kind === 'join')
-                    throw new SquareError('invalid_args', 'A participant seat can only be re-established by join.');
+                    throw new SquareError('invalid_args', 'A participant seat can only be established by join.');
             }
             else if (authority.kind === 'host-cleanup') {
-                assertSeat(authority.seat, authority.seat, true);
+                assertCurrentSeat(read, authority.seat, true);
                 if (activity.kind !== 'done')
                     throw new SquareError('invalid_args', 'Host cleanup may only end membership.');
             }
             else if (authority.kind === 'join') {
-                if (activity.kind !== 'join')
-                    throw new SquareError('invalid_args', 'A new seat must be established by its join activity.');
-                if (read.participant(expectedName)?.joined)
-                    throw new SquareError('already_joined', `${expectedName} is already standing; join cannot replace an existing seat.`);
+                if (activity.kind !== 'join' || read.participant(name)?.joined)
+                    throw new SquareError('already_joined', 'A new seat requires a new join.');
             }
             else if (takeoverPhase === 'ready') {
-                const current = read.seat(expectedName);
-                if (activity.kind !== 'done' || current === undefined || current.generation !== authority.expectedGeneration)
+                if (activity.kind !== 'done' || read.seat(name)?.generation !== authority.expectedGeneration)
                     throw new SquareError('already_joined', 'Takeover must first complete the captured participant.');
             }
-            else if (authority.kind === 'takeover' && takeoverPhase === 'done') {
-                if (activity.kind !== 'join' || !read.participant(expectedName)?.done)
+            else if (takeoverPhase === 'done') {
+                if (activity.kind !== 'join' || !read.participant(name)?.done)
                     throw new SquareError('already_joined', 'Takeover must join after its captured done activity.');
             }
-            else {
+            else
                 throw new SquareError('invalid_args', 'Takeover permits only one done followed by one join.');
-            }
             const index = read.header().nextActIndex;
             if (!Number.isSafeInteger(index) || index < 0 || index >= Number.MAX_SAFE_INTEGER)
                 throw new SquareError('invalid_args', 'Square activity index is exhausted.');
-            const captured = authority.kind === 'takeover' && activity.kind === 'done'
-                ? read.seat(expectedName) : undefined;
+            const captured = authority.kind === 'takeover' && activity.kind === 'done' ? read.seat(name) : undefined;
             const stored = { ...activity, index };
-            applyLanding(deriveLanding(stored, landingFacts(read, stored)));
+            writes.applyLanding(deriveLanding(stored, landingFacts(read, activity)));
             if (stored.kind === 'join') {
                 if (authority.kind !== 'join' && authority.kind !== 'takeover')
                     throw new SquareError('invalid_args', 'Seat authority cannot establish another seat.');
-                const seat = {
-                    participant: stored.actor,
-                    owner: authority.owner,
-                    generation: formatActivityId(stored.index),
-                    attachment: 'attached',
-                    ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }),
-                };
-                mutations.storeSeat(seat);
-                const established = read.seat(seat.participant);
-                if (established === undefined || established.owner !== seat.owner || established.generation !== seat.generation)
-                    throw new SquareError('invalid_args', 'The join activity did not establish its artifact seat.');
+                const seat = { participant: stored.actor, owner: authority.owner, generation: newEndpointGeneration(), attachment: 'attached', ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }) };
+                writes.storeSeat(seat);
+                establishedSeat = seat;
                 if (authority.kind === 'takeover')
                     takeoverPhase = 'joined';
             }
             else if (stored.kind === 'done' && seated) {
-                if (!mutations.removeSeat(authority.seat))
-                    throw new SquareError('already_joined', 'The participant seat changed while it was being completed.');
+                if (!writes.removeSeat(authority.seat))
+                    throw new SquareError('already_joined', 'The participant seat changed while completing it.');
             }
             else if (stored.kind === 'done' && authority.kind === 'takeover') {
-                if (captured === undefined || !mutations.removeSeat({ participant: expectedName, owner: captured.owner, generation: captured.generation }))
-                    throw new SquareError('already_joined', 'The participant seat changed while takeover was completing it.');
+                if (captured === undefined || !writes.removeSeat(captured))
+                    throw new SquareError('already_joined', 'The participant seat changed while takeover completed it.');
                 takeoverPhase = 'done';
             }
-            lastActivity = read.activity(index);
-            return lastActivity;
-        },
-        updateWakeAddress(seat, wakeAddress) {
-            if (authority.kind !== 'join' && authority.kind !== 'participant')
-                throw new SquareError('already_joined', 'This write needs the current participant seat.');
-            assertSeat(seat, authority.kind === 'join' ? reconnectSeat : authority.seat);
-            return mutations.updateWakeAddress(seat, wakeAddress);
-        },
-        reattachSeat(seat, wakeAddress) {
-            if (authority.kind !== 'join')
-                throw new SquareError('already_joined', 'Reattachment requires a same-owner join.');
-            assertSeat(seat, reconnectSeat, true);
-            return mutations.reattachSeat(seat, wakeAddress);
-        },
-        detachSeat(seat) {
-            if (authority.kind !== 'host-cleanup')
-                throw new SquareError('already_joined', 'Detach requires captured host cleanup authority.');
-            const current = read.seat(seat.participant), expected = authority.seat;
-            if (!sameName(seat.participant, expected.participant) || seat.owner !== expected.owner || seat.generation !== expected.generation)
-                throw new SquareError('already_joined', 'Host cleanup does not match its captured seat.');
-            if (current === undefined || current.attachment !== 'attached' || current.owner !== expected.owner
-                || current.generation !== expected.generation)
-                return false;
-            return mutations.detachSeat(seat);
-        },
-        cancelThrough(seat, through) {
-            assertSeat(seat);
-            if (!Number.isSafeInteger(through) || through < 0 || through >= read.header().nextActIndex)
-                throw new SquareError('invalid_args', 'Cancellation boundary must be an assigned activity index below the allocator.');
-            return mutations.cancelThrough(seat, through);
-        },
-        markSeen(name, indexes, at) {
-            assertParticipant(name);
-            return mutations.markSeen(name, indexes, at);
-        },
-        putLease(name, lease, generation) {
-            assertParticipant(name, generation);
-            return mutations.putLease(name, lease, generation);
-        },
-        removeLease(name, leaseId, generation) {
-            assertParticipant(name, generation);
-            return mutations.removeLease(name, leaseId, generation);
-        },
-        putDeliveryDeferral(...args) {
-            assertSeat(args[0]);
-            return mutations.putDeliveryDeferral(...args);
-        },
-        renewDeliveryDeferral(...args) {
-            assertSeat(args[0]);
-            return mutations.renewDeliveryDeferral(...args);
-        },
-        releaseDeliveryDeferral(...args) {
-            assertSeat(args[0]);
-            return mutations.releaseDeliveryDeferral(...args);
-        },
-        claimDelivery(input) {
-            assertSeat(input.seat);
-            const evidence = read.deliveryEvidence(input.seat.participant, input.seat.generation, input.activity);
-            if (input.observationOf !== undefined) {
-                // Receiver adapters validate native identity/content before entering this transaction.
-                // This path records that existing message, rather than acquiring a second send.
-                if (input.kind !== 'presentation' || !evidence.some(row => row.kind === 'wake'
-                    && row.claimToken === input.observationOf && ['dispatching', 'accepted', 'unknown'].includes(row.outcome)))
-                    return { status: 'stale' };
-            }
-            else {
-                const blocker = evidence.find(row => row.kind !== input.kind
-                    && row.outcome !== 'failed' && row.outcome !== 'released');
-                if (blocker !== undefined) {
-                    if (blocker.outcome === 'dispatching' && blocker.expiresAt !== undefined && blocker.expiresAt <= input.at) {
-                        // Normalize abandoned custody to unknown in the same transaction, never steal it.
-                        return mutations.claimDelivery({ ...input, kind: blocker.kind });
-                    }
-                    return { status: blocker.outcome === 'dispatching' ? 'busy' : 'terminal', evidence: blocker };
-                }
-            }
-            return mutations.claimDelivery(input);
-        },
-        prepareDelivery(input) {
-            assertSeat(input.seat);
-            return mutations.prepareDelivery(input);
-        },
-        completeDelivery(input) {
-            assertSeat(input.seat);
-            return mutations.completeDelivery(input);
-        },
-        observeNativeDelivery(input) {
-            assertSeat(input.seat);
-            return mutations.observeNativeDelivery(input);
-        },
+            // Return the persisted, detached fact rather than freezing the caller's draft.
+            const landed = read.activity(index);
+            if (landed === undefined)
+                throw new SquareError('invalid_args', 'The activity did not land.');
+            return landed;
+        },
+        putLease(name, lease, generation) { participant(name, generation); return writes.putLease(name, lease, generation); },
+        removeLease(name, leaseId, generation) { participant(name, generation); return writes.removeLease(name, leaseId, generation); },
+        markSeen(name, indexes, at) { participant(name); return writes.markSeen(name, indexes, at); },
+        ackMatching(seat, input, at) { participant(seat.participant, seat.generation); if (authority.kind !== 'participant' || authority.seat.owner !== seat.owner)
+            throw new SquareError('already_joined', 'Seat owner changed.'); return writes.ackMatching(seat, input, at); },
     });
-    return {
-        facts,
-        complete() {
+    return { facts, complete() {
             if (authority.kind !== 'takeover')
                 return;
-            const seat = read.seat(expectedName);
-            if (takeoverPhase !== 'joined' || lastActivity?.kind !== 'join' || seat === undefined
-                || seat.owner !== authority.owner || seat.generation !== formatActivityId(lastActivity.index))
+            const seat = read.seat(name);
+            if (takeoverPhase !== 'joined' || seat === undefined || establishedSeat === undefined || seat.owner !== establishedSeat.owner || seat.generation !== establishedSeat.generation)
                 throw new SquareError('already_joined', 'Takeover did not complete its replacement join.');
-        },
-    };
+        } };
 }