@astrosheep/square 0.3.106 → 0.4.0

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

@@ -27,4 +27,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,10 +26,10 @@ export type Act = {
     at?: number;
     body?: string;
     metadata?: import('./model.js').ActivityMetadata;
-    delivery?: import('./model.js').ActivityDelivery;
     mentions?: readonly Participant[];
     reach?: Reach;
     reply?: number;
+    messageIndex?: number;
 } | {
     kind: 'read';
     actor: Participant;

package/dist/square-domain.d.ts

@@ -1,7 +1,16 @@
-import { type Seat, type StoredAct } from './model.js';
+import { type ActDraft, type Seat, type StoredAct } from './model.js';
+import { type EndpointGeneration } from './message.js';
 import type { ArtifactWriteAuthority, AttentionFact, LandedRecipient, ParticipantFact, SeatRef, SquareRead, SquareWrite } from './ports.js';
+import type { ChannelWrite, EndpointRef } from './channel-ports.js';
+import type { WatchLease } from './model.js';
+/** Pending messages the live catch currently owns; the lower pipeline only needs this coverage. */
+export declare function catchCoverage(read: SquareRead, name: string, lease: WatchLease): number[];
+/** Artifact-private landing effect; sender capabilities never expose another recipient's claim. */
+export declare function extendLandingCatchCoverage(read: SquareRead, putClaim: ChannelWrite['putReceiveClaim'], activity: StoredAct, audience: readonly LandedRecipient[]): void;
 export interface LandingEffect {
-    readonly activity: StoredAct;
+    readonly activity: ActDraft & {
+        readonly index: number;
+    };
     readonly participant?: ParticipantFact;
     readonly removeListeningOf?: string;
     readonly removeListening?: {
@@ -14,18 +23,23 @@ export interface LandingEffect {
 export interface LandingFacts {
     readonly actor?: ParticipantFact;
     readonly standing: readonly ParticipantFact[];
+    /** Endpoint custody at landing time, so an address fences the generation it was written for. */
+    readonly generations: ReadonlyMap<string, EndpointGeneration>;
     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' | 'updateWakeAddress' | 'reattachSeat' | 'detachSeat'> {
+    /** Artifact-private endpoint persistence used only by this gate's lifecycle transition. */
     storeSeat(seat: Seat): boolean;
-    removeSeat(seat: import('./ports.js').SeatRef): boolean;
+    removeSeat(seat: EndpointRef): boolean;
     applyLanding(effect: LandingEffect): void;
+    readonly channel: ChannelWrite;
 }
 export interface SquareWriteGate {
     readonly facts: SquareWrite;

package/dist/square-domain.js

@@ -1,21 +1,51 @@
-import { SquareError, formatActivityId, parseActivityId, sameName, validateActivityDelivery, validateOwner, validateName } from './model.js';
+import { SquareError, nameKey, sameName, validateOwner, validateName } from './model.js';
+import { wrapChannelWrite } from './channel-domain.js';
+import { newEndpointGeneration } from './message.js';
 import { resolveAudience } from './attention.js';
-/** The single landing transition, shared by both adapters and explicit rebuild. */
-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' });
+import { validateEndpointGeneration as endpointGeneration } from './message.js';
+import { leaseOwnsNotification } from './catch-selection.js';
+/** Pending messages the live catch currently owns; the lower pipeline only needs this coverage. */
+export function catchCoverage(read, name, lease) {
+    const covered = [];
+    let cursor = -1;
+    for (;;) {
+        const page = read.channel.directed(name, { afterIndex: cursor, unseenOnly: true, currentGeneration: true }, { edge: 'oldest', limit: 100 });
+        for (const head of page.items) {
+            const relation = read.activityByMessage(head.index);
+            const route = relation === undefined ? undefined : read.directedAt(name, relation.index)?.route;
+            if (route !== undefined && leaseOwnsNotification(lease, { actor: head.from, route, recipient: name }))
+                covered.push(head.index);
         }
-        return { activity, audience };
+        if (!page.hasMore || page.items.length === 0)
+            break;
+        cursor = page.items[page.items.length - 1].index;
+    }
+    return covered;
+}
+/** Artifact-private landing effect; sender capabilities never expose another recipient's claim. */
+export function extendLandingCatchCoverage(read, putClaim, activity, audience) {
+    if (activity.kind !== 'say')
+        return;
+    const index = activity.messageIndex;
+    for (const recipient of audience) {
+        const claim = read.channel.claimLease(recipient.recipient, 'agora');
+        if (claim === undefined || claim.expiresAt <= activity.at || recipient.generation !== undefined && claim.generation !== recipient.generation)
+            continue;
+        const lease = read.lease(recipient.recipient);
+        if (lease === undefined || lease.leaseId !== claim.id
+            || !leaseOwnsNotification(lease, { actor: activity.actor, route: recipient.route, recipient: recipient.recipient }))
+            continue;
+        if (!claim.suppressed.includes(index))
+            putClaim({ ...claim, suppressed: [...claim.suppressed, index] });
     }
+}
+/** The single landing transition, shared by both adapters and explicit rebuild. */
+export function deriveLanding(activity, facts) {
     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,
-    }) : [];
+    }).map(recipient => ({ ...recipient, generation: facts.generations.get(nameKey(recipient.recipient)) })) : [];
     const actor = activity.actor;
     const previous = facts.actor ?? { name: actor, firstIndex: activity.index, joined: false, done: false, sayCount: 0 };
     const participant = {
@@ -45,6 +75,7 @@ export function deriveLanding(activity, facts) {
 export function landingFacts(read, activity) {
     return {
         actor: read.participant(activity.actor),
+        generations: new Map(read.channel.endpoints().map(endpoint => [nameKey(endpoint.participant), endpoint.generation])),
         standing: activity.kind === 'say' ? read.roster().filter((item) => item.joined) : [],
         incoming: activity.kind === 'say' ? read.incomingAttention(activity.actor) : [],
         outgoing: activity.kind === 'listen' || activity.kind === 'ignore' || activity.kind === 'unlisten' ? read.attention(activity.actor) : [],
@@ -52,8 +83,7 @@ export function landingFacts(read, activity) {
     };
 }
 function validateGeneration(value) {
-    if (typeof value !== 'string' || parseActivityId(value) === undefined)
-        throw new SquareError('invalid_args', 'Artifact authority requires a valid join generation.');
+    endpointGeneration(value);
 }
 /** Read probes and writes share the same captured-coordinate and attachment fence. */
 export function assertCurrentSeat(read, expected, allowDetached = false) {
@@ -63,14 +93,21 @@ 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 });
 }
+function immutableAct(activity) {
+    const copy = { ...activity, ...(activity.kind === 'say' && activity.mentions !== undefined ? { mentions: [...activity.mentions] } : {}) };
+    if (copy.kind === 'say' && copy.mentions !== undefined)
+        Object.freeze(copy.mentions);
+    return Object.freeze(copy);
+}
 /** 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)
         throw new SquareError('invalid_args', 'Artifact writes require an explicit authority.');
-    const { applyLanding, ...mutations } = writes;
-    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')
+    const { applyLanding, channel, ...mutations } = writes;
+    const seated = authority.kind === 'participant' || authority.kind === 'host-cleanup' || authority.kind === 'endpoint-cleanup';
+    const expectedName = seated ? authority.seat?.participant : authority.kind === 'send' ? authority.actor
+        : authority.kind === 'endpoint' ? authority.participant : authority.participant;
+    if (!['participant', 'host-cleanup', 'endpoint-cleanup', 'endpoint', 'join', 'takeover', 'send'].includes(authority.kind) || typeof expectedName !== 'string')
         throw new SquareError('invalid_args', 'Artifact write authority is malformed.');
     validateName(expectedName);
     if (seated) {
@@ -82,7 +119,7 @@ export function wrapSquareWrite(read, writes, authority) {
         if (authority.kind === 'takeover')
             validateGeneration(authority.expectedGeneration);
     }
-    const assertSeat = (seat, expected = authority.kind === 'participant' ? authority.seat : undefined, allowDetached = false) => {
+    const assertSeat = (seat, expected = authority.kind === 'participant' || authority.kind === 'host-cleanup' || authority.kind === 'endpoint-cleanup' ? 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.');
@@ -91,16 +128,20 @@ export function wrapSquareWrite(read, writes, authority) {
     const assertParticipant = (name, generation) => {
         if (authority.kind !== 'participant')
             throw new SquareError('already_joined', 'This write needs the current participant seat.');
-        assertSeat({ ...authority.seat, participant: name, generation: generation === undefined ? authority.seat.generation : generation });
+        assertSeat({ ...authority.seat, participant: name, generation: generation ?? authority.seat.generation });
     };
     let reconnectSeat;
     let takeoverPhase = authority.kind === 'takeover' ? 'ready' : undefined;
+    let establishedSeat;
     if (authority.kind === 'participant') {
         assertSeat(authority.seat);
     }
-    else if (authority.kind === 'host-cleanup') {
+    else if (authority.kind === 'host-cleanup' || authority.kind === 'endpoint-cleanup') {
         // A late host cleanup is allowed to inspect a stale coordinate and return a no-op.
     }
+    else if (authority.kind === 'endpoint') {
+        // Endpoint attach/takeover owns no activity.
+    }
     else if (authority.kind === 'join') {
         const participant = read.participant(expectedName), seat = read.seat(expectedName);
         if (participant?.joined) {
@@ -115,7 +156,12 @@ export function wrapSquareWrite(read, writes, authority) {
             throw new SquareError('already_joined', 'The participant seat changed before takeover.');
     }
     let lastActivity;
+    const lowerAuthority = authority.kind === 'join' || authority.kind === 'takeover'
+        ? { kind: 'endpoint', participant: authority.participant, owner: authority.owner }
+        : authority.kind === 'host-cleanup' ? { kind: 'endpoint-cleanup', seat: authority.seat } : authority;
+    const gatedChannel = wrapChannelWrite(read.channel, channel, lowerAuthority);
     const facts = Object.assign({}, read, {
+        channel: gatedChannel,
         land(activity) {
             const actor = 'actor' in activity ? activity.actor : undefined;
             if (actor === undefined)
@@ -123,11 +169,8 @@ export function wrapSquareWrite(read, writes, authority) {
             validateName(actor);
             if (!sameName(actor, expectedName))
                 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.');
+            if (authority.kind === 'send' || authority.kind === 'endpoint' || authority.kind === 'endpoint-cleanup') {
+                throw new SquareError('invalid_args', 'This authority may not publish Agora activities.');
             }
             else if (authority.kind === 'participant') {
                 assertSeat(authority.seat);
@@ -160,37 +203,50 @@ export function wrapSquareWrite(read, writes, authority) {
             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 stored = { ...activity, index };
-            applyLanding(deriveLanding(stored, landingFacts(read, stored)));
+            const captured = authority.kind === 'takeover' && activity.kind === 'done' ? read.seat(expectedName) : undefined;
+            const effect = deriveLanding({ ...activity, index }, landingFacts(read, activity));
+            let stored;
+            if (activity.kind === 'say') {
+                const published = gatedChannel.publishMessage({ from: activity.actor, at: activity.at,
+                    body: activity.body ?? '', ...(activity.metadata === undefined ? {} : { metadata: activity.metadata }),
+                    to: effect.audience.map(({ recipient, generation }) => ({ recipient, ...(generation === undefined ? {} : { generation }) })) });
+                // The published content lives in the message; only the relation is stored above it.
+                const { body: _body, metadata: _metadata, ...relation } = activity;
+                stored = { ...relation, index, messageIndex: published.index };
+            }
+            else {
+                stored = { ...activity, index };
+            }
+            applyLanding({ ...effect, activity: stored });
             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),
+                    generation: newEndpointGeneration(),
                     attachment: 'attached',
                     ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }),
                 };
                 mutations.storeSeat(seat);
+                establishedSeat = 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.');
+                    throw new SquareError('invalid_args', 'The join activity did not establish its artifact endpoint.');
                 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.');
+                    throw new SquareError('already_joined', 'The participant endpoint changed while it was being completed.');
             }
             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.');
+                    throw new SquareError('already_joined', 'The participant endpoint changed while takeover was completing it.');
                 takeoverPhase = 'done';
             }
-            lastActivity = read.activity(index);
+            // The persisted fact is the relation; callers that present a say resolve its message content.
+            lastActivity = immutableAct(stored);
             return lastActivity;
         },
         updateWakeAddress(seat, wakeAddress) {
@@ -216,71 +272,14 @@ export function wrapSquareWrite(read, writes, authority) {
                 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);
+            return mutations.putLease(name, lease, generation, catchCoverage(read, name, lease));
         },
         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 {
         facts,
@@ -288,8 +287,8 @@ export function wrapSquareWrite(read, writes, authority) {
             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))
+            if (takeoverPhase !== 'joined' || lastActivity?.kind !== 'join' || seat === undefined || establishedSeat === undefined
+                || seat.owner !== establishedSeat.owner || seat.generation !== establishedSeat.generation)
                 throw new SquareError('already_joined', 'Takeover did not complete its replacement join.');
         },
     };

package/dist/square-facade.d.ts

@@ -1,12 +1,17 @@
 import type { DeliveryDeferral, MetadataMatch } from './delivery-deferral.js';
 export type { DeliveryDeferral, MetadataMatch, MetadataScalar } from './delivery-deferral.js';
 import type { ActivityId, Perception, Reach } from './square-core.js';
-import type { Owner, StoredAct, WakeAddress, ActivityMetadata, ActivityDelivery, DirectedNotificationRoute } from './model.js';
+import type { Owner, HydratedAct, WakeAddress, ActivityMetadata, DirectedNotificationRoute } from './model.js';
 import type { WakeTransportPort, SquareResourceOwner } from './ports.js';
+import type { OperationControl } from './neutral.js';
+import type { MessageSearch as ActivitySearch, AckResult } from './channel-facade.js';
+export type { ChannelTruncate, ChannelSendInput, ChannelSendResult, ChannelEndpointSummary, ChannelMessage, ChannelPendingResult, MessageCursor, MessageQuery, ChannelHistoryQuery, ChannelPendingOptions, ChannelHistoryResult, ChannelReceiveResult, MessageSearch as ActivitySearch, AckResult, ChannelEndpointHold as HeldSeat } from './channel-facade.js';
+export type { CatchWaitStart, OperationProgress, OperationControl, OperationFailureDetail, OperationError } from './neutral.js';
 export type { ActivityId, Perception, Reach } from './square-core.js';
-export type { Owner, WakeAddress, ActivityMetadata, ActivityDelivery, JsonValue, DirectedNotificationRoute } from './model.js';
-/** Indexed archive event, including read bookkeeping. */
-export type ArchiveRecord = Readonly<StoredAct>;
+export type { MessageId } from './message.js';
+export type { Owner, WakeAddress, ActivityMetadata, JsonValue, DirectedNotificationRoute } from './model.js';
+/** Indexed archive event, including read bookkeeping and a say's linked content. */
+export type ArchiveRecord = Readonly<HydratedAct>;
 export interface Activity {
     readonly id: ActivityId;
     readonly at: number;
@@ -14,11 +19,12 @@ export interface Activity {
     readonly actor: string;
     readonly body?: string;
     readonly metadata?: ActivityMetadata;
-    readonly delivery?: ActivityDelivery;
     readonly mentions: readonly string[];
     readonly reach?: Reach;
     readonly target?: string;
     readonly reply?: ActivityId;
+    /** Channel message owning a say's body and metadata. */
+    readonly messageId?: import('./message.js').MessageId;
 }
 export interface PerceivedActivity extends Activity {
     readonly perception: Perception;
@@ -50,22 +56,6 @@ export interface ExpressResult {
     readonly hint?: string;
     readonly observation?: ExpressObservation;
 }
-export type ChannelTruncate = number | false;
-export interface ChannelSendInput {
-    readonly from: string;
-    readonly to: string | readonly string[];
-    readonly body: string;
-    readonly truncate?: ChannelTruncate;
-    readonly metadata?: ActivityMetadata;
-}
-export interface ChannelSendResult {
-    readonly id: ActivityId;
-    readonly at: number;
-    readonly from: string;
-    readonly to: readonly string[];
-    readonly body: string;
-    readonly metadata?: ActivityMetadata;
-}
 export interface ListenerChangeResult {
     readonly activity: Activity | null;
     readonly observation?: ListenerObservation;
@@ -86,10 +76,6 @@ export interface CatchOptions extends ObservationOptions {
     readonly limit?: number;
     readonly replace?: boolean;
 }
-export interface ActivitySearch {
-    readonly text: string;
-    readonly mode: 'literal' | 'regex';
-}
 export interface ActivityCursor {
     readonly id: ActivityId;
     readonly direction: 'before' | 'after';
@@ -111,10 +97,6 @@ export interface PendingResult {
     /** Matching unconsumed activities outside this page. */
     readonly remaining: number;
 }
-export interface AckResult {
-    /** Newly consumed addressed IDs; repeated acknowledgement is a no-op. */
-    readonly consumed: number;
-}
 export type CatchReason = 'drained' | 'idle' | 'capped' | 'quorum' | 'replaced' | 'already-active';
 export interface CatchResult {
     readonly activities: readonly PerceivedActivity[];
@@ -124,37 +106,6 @@ export interface CatchResult {
     readonly hint?: string;
     readonly observation?: CatchObservation;
 }
-export interface CatchWaitStart {
-    readonly idleMs: number;
-    readonly replacementRequested: boolean;
-    readonly replaced: boolean;
-}
-export type OperationProgress = {
-    readonly kind: 'waiting';
-    readonly reason: 'throttled';
-    readonly delayMs?: number;
-} | ({
-    readonly kind: 'catch-started';
-    readonly participant: string;
-} & CatchWaitStart);
-export interface OperationControl {
-    readonly signal?: AbortSignal;
-    readonly onProgress?: (progress: OperationProgress) => void;
-}
-export interface OperationFailureDetail {
-    readonly operation: 'express' | 'join' | 'catch' | 'history' | 'other';
-    readonly subject?: 'caller' | 'filter' | 'recipient';
-    readonly participant?: string;
-    readonly expressEffect?: 'unsent' | 'landed' | 'unknown';
-    readonly landedId?: ActivityId;
-    readonly historyBounds?: {
-        readonly maxLimit: number;
-        readonly totalMatches: number;
-    };
-}
-export interface OperationError extends Error {
-    readonly operation?: OperationFailureDetail;
-}
 export interface HistoryQuery extends ActivityQuery, ObservationOptions {
     /** Ten by default; null explicitly reads the full archive. */
     readonly limit?: number | null;
@@ -202,7 +153,7 @@ export interface JoinResult {
 }
 export interface Participant {
     readonly name: string;
-    readonly generation: ActivityId;
+    readonly generation: string;
     express(body: string | undefined, options?: ExpressOptions, control?: OperationControl): Promise<ExpressResult>;
     express(input: ExpressInput, control?: OperationControl): Promise<ExpressResult>;
     listen(target: string, options?: ObservationOptions, control?: OperationControl): Promise<ListenerChangeResult>;
@@ -221,11 +172,6 @@ export interface Participant {
     renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
     releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
 }
-export interface HeldSeat {
-    readonly name: string;
-    readonly generation: ActivityId;
-    readonly attachment: 'attached' | 'detached';
-}
 export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'away' | 'done';
 export interface ParticipantSummary {
     readonly name: string;

package/dist/square-index.d.ts

@@ -1,5 +1,5 @@
 import { type VersionObserver } from './file-changes.js';
-import { type Owner } from './model.js';
+import { type Owner } from './neutral.js';
 /** A rebuildable discovery hint: the owner that may have used an artifact and its path. */
 export interface SquareIndexEntry {
     readonly location: string;

package/dist/square-index.js

@@ -5,7 +5,7 @@ import { randomUUID } from 'node:crypto';
 import { withFileLock } from './file-lock.js';
 import { canonicalPath } from './canonical-path.js';
 import { observeFileMetadata } from './file-changes.js';
-import { validateOwner } from './model.js';
+import { validateOwner } from './neutral.js';
 export function squareIndexPath(env = process.env) {
     const configured = env.SQUARE_INDEX?.trim();
     return path.resolve(configured ?? path.join(os.homedir(), '.square', 'index.ndjsonl'));

package/dist/square-location.d.ts

@@ -1,2 +1,7 @@
-import type { SquareLocation } from './square-facade.js';
+interface SquareLocation {
+    readonly path?: string;
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
 export declare function squareLocation(input: SquareLocation): string;
+export {};

package/dist/square-location.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { SquareError } from './model.js';
+import { SquareError } from './neutral.js';
 export function squareLocation(input) {
     const selected = input.path ?? (input.env ?? process.env).SQUARE_LOCATION;
     if (selected === undefined || selected.trim() === '')