@astrosheep/square 0.4.0 → 0.4.1

package/dist/square-domain.js

@@ -1,91 +1,47 @@
 import { SquareError, nameKey, sameName, validateOwner, validateName } from './model.js';
-import { wrapChannelWrite } from './channel-domain.js';
-import { newEndpointGeneration } from './message.js';
+import { newEndpointGeneration, validateEndpointGeneration } from './message.js';
 import { resolveAudience } from './attention.js';
-import { validateEndpointGeneration as endpointGeneration } from './message.js';
+import { freshWatchLease } from './runtime.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);
-        }
-        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 };
+        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 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),
-        generations: new Map(read.channel.endpoints().map(endpoint => [nameKey(endpoint.participant), endpoint.generation])),
-        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) {
-    endpointGeneration(value);
+        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)
@@ -93,203 +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 });
 }
-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)
+    if (!authority || typeof authority !== 'object')
         throw new SquareError('invalid_args', 'Artifact writes require an explicit authority.');
-    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);
+    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 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.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.');
-        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 ?? authority.seat.generation });
+        assertCurrentSeat(read, authority.seat);
     };
-    let reconnectSeat;
-    let takeoverPhase = authority.kind === 'takeover' ? 'ready' : undefined;
-    let establishedSeat;
-    if (authority.kind === 'participant') {
-        assertSeat(authority.seat);
-    }
-    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) {
-            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 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,
+    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 (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);
+            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 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 });
+            const captured = authority.kind === 'takeover' && activity.kind === 'done' ? read.seat(name) : undefined;
+            const stored = { ...activity, index };
+            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: newEndpointGeneration(),
-                    attachment: 'attached',
-                    ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }),
-                };
-                mutations.storeSeat(seat);
+                const seat = { participant: stored.actor, owner: authority.owner, generation: newEndpointGeneration(), attachment: 'attached', ...(authority.wakeAddress === undefined ? {} : { wakeAddress: authority.wakeAddress }) };
+                writes.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 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 endpoint 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 endpoint 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';
             }
-            // The persisted fact is the relation; callers that present a say resolve its message content.
-            lastActivity = immutableAct(stored);
-            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);
-        },
-        putLease(name, lease, generation) {
-            assertParticipant(name, generation);
-            return mutations.putLease(name, lease, generation, catchCoverage(read, name, lease));
-        },
-        removeLease(name, leaseId, generation) {
-            assertParticipant(name, generation);
-            return mutations.removeLease(name, leaseId, generation);
+            // 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 || establishedSeat === undefined
-                || seat.owner !== establishedSeat.owner || seat.generation !== establishedSeat.generation)
+            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.');
-        },
-    };
+        } };
 }

package/dist/square-facade.d.ts

@@ -1,14 +1,24 @@
-import type { DeliveryDeferral, MetadataMatch } from './delivery-deferral.js';
-export type { DeliveryDeferral, MetadataMatch, MetadataScalar } from './delivery-deferral.js';
+import type { MetadataMatch } from './delivery-deferral.js';
+export type { MetadataMatch, MetadataScalar } from './delivery-deferral.js';
 import type { ActivityId, Perception, Reach } from './square-core.js';
 import type { Owner, HydratedAct, WakeAddress, ActivityMetadata, DirectedNotificationRoute } from './model.js';
-import type { WakeTransportPort, SquareResourceOwner } from './ports.js';
+import type { 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 interface ActivitySearch {
+    readonly text: string;
+    readonly mode: 'literal' | 'regex';
+}
+export interface AckResult {
+    readonly consumed: number;
+}
+import type { FutureAck } from './square-post.js';
+export type { NotificationId, SendInput, SendResult, FutureAck } from './square-post.js';
+export interface HeldSeat {
+    readonly name: string;
+    readonly generation: string;
+}
 export type { CatchWaitStart, OperationProgress, OperationControl, OperationFailureDetail, OperationError } from './neutral.js';
 export type { ActivityId, Perception, Reach } from './square-core.js';
-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>;
@@ -23,8 +33,6 @@ export interface Activity {
     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;
@@ -121,7 +129,6 @@ export interface HistoryResult {
 }
 export interface OpenOptions {
     readonly clock?: () => number;
-    readonly wakeTransport?: WakeTransportPort | false;
 }
 export interface SquareLocation {
     readonly path?: string;
@@ -162,15 +169,11 @@ export interface Participant {
     listening(options?: ObservationOptions, control?: OperationControl): Promise<ListeningResult>;
     catch(options?: CatchOptions, control?: OperationControl): Promise<CatchResult>;
     pending(options?: PendingOptions, control?: OperationControl): Promise<PendingResult>;
+    /** Local custody only: ledger-only detach/delete is observed on privileged reconciliation. */
     ack(ids: readonly ActivityId[], control?: OperationControl): Promise<AckResult>;
+    ack(input: FutureAck, control?: OperationControl): Promise<AckResult>;
     /** Leave without a message. Only an omitted or empty body is accepted. */
     done(body?: string, options?: ObservationOptions, control?: OperationControl): Promise<LifecycleResult>;
-    deferDelivery(input: Readonly<{
-        match: MetadataMatch;
-        durationMs: number;
-    }>, control?: OperationControl): Promise<DeliveryDeferral>;
-    renewDeliveryDeferral(id: string, durationMs: number, control?: OperationControl): Promise<DeliveryDeferral | null>;
-    releaseDeliveryDeferral(id: string, control?: OperationControl): Promise<boolean>;
 }
 export type ParticipantPresence = 'never-joined' | 'active' | 'watching' | 'away' | 'done';
 export interface ParticipantSummary {

package/dist/square-post.d.ts

@@ -0,0 +1,53 @@
+import { type ActivityMetadata, type DirectedNotificationRoute, type Owner } from './model.js';
+import type { MetadataMatch } from './delivery-deferral.js';
+import type { SeatRef } from './ports.js';
+/** Producer notices are not activities in the square. */
+export type NotificationId = `notice/${number}`;
+export interface SendInput {
+    readonly from: string;
+    readonly to: string | readonly string[];
+    readonly body: string;
+    readonly metadata?: ActivityMetadata;
+}
+export interface SendResult {
+    readonly id: NotificationId;
+    readonly at: number;
+    readonly from: string;
+    readonly to: readonly string[];
+    readonly body: string;
+    readonly metadata?: ActivityMetadata;
+}
+/** The caller supplies every scalar equality identifying one exact outcome. */
+export interface FutureAck {
+    readonly from: string;
+    readonly match: MetadataMatch;
+    readonly future: 'exact';
+}
+/** One Square-owned recipient card; neither an endpoint nor a shared message resource. */
+export interface SquarePost {
+    readonly kind: 'activity' | 'notice';
+    readonly index: number;
+    readonly recipient: string;
+    readonly owner: Owner;
+    readonly generation: string;
+    readonly from: string;
+    readonly at: number;
+    readonly body?: string;
+    readonly metadata?: ActivityMetadata;
+    readonly route?: DirectedNotificationRoute;
+    readonly full?: boolean;
+    readonly consumed?: boolean;
+}
+export interface ProducerRead {
+    pendingPosts(): readonly SquarePost[];
+    postedPosts(): readonly SquarePost[];
+    ownsPost(token: string, exportAt?: number): boolean;
+}
+export interface ProducerWrite {
+    insertNotice(input: SendInput, at: number): SendResult;
+    ackMatching(seat: SeatRef, input: FutureAck, at: number): number;
+    acquirePost(post: SquarePost, token: string, pid: number, now: number, exportAt?: number): false | 'initial' | 'recovered';
+    settlePost(token: string, full: boolean, disposition: 'posted' | 'uncertain' | 'never-exported'): boolean;
+    foldReceipt(post: SquarePost, at: number): boolean;
+}
+export declare function squarePostKey(location: string, post: Pick<SquarePost, 'kind' | 'index' | 'recipient' | 'generation'>): string;

package/dist/square-post.js

@@ -0,0 +1,4 @@
+import { nameKey } from './model.js';
+export function squarePostKey(location, post) {
+    return `square:${location}#${post.kind === 'activity' ? 'act' : 'notice'}/${post.index}/recipient/${encodeURIComponent(nameKey(post.recipient))}/join/${encodeURIComponent(post.generation)}`;
+}

package/dist/square-posting.d.ts

@@ -0,0 +1,13 @@
+import { DeliveryLedger, type DeliveryRoute, type DeliverySession } from './delivery-ledger.js';
+import { type Seat } from './model.js';
+import type { SquareArtifactPort } from './ports.js';
+/** Local producer custody and current host attachment are different observations. */
+export declare function deliverySessionsForSeats(ledger: DeliveryLedger, seats: readonly Seat[]): Promise<ReadonlyMap<string, DeliverySession | undefined>>;
+/** Read-only host observations for status; callers fence them against the captured World seats. */
+export declare function readSquareSessions(seats: readonly Seat[], env: NodeJS.ProcessEnv): Promise<ReadonlyMap<string, DeliverySession | undefined>>;
+/** A first producer join may register an absent owner, never resume or revive one. */
+export declare function ensureInitialDeliverySession(owner: Seat['owner'], env: NodeJS.ProcessEnv, route?: DeliveryRoute): Promise<boolean>;
+/** Called only by privileged mutations. Sandbox lease/ACK/selection never enters here. */
+export declare function reconcileSquareDelivery(artifact: SquareArtifactPort, location: string, env: NodeJS.ProcessEnv, clock: () => number): Promise<void>;
+/** One export path for Square activities and Square-owned notices. No transaction spans I/O. */
+export declare function flushSquarePosts(artifact: SquareArtifactPort, location: string, env: NodeJS.ProcessEnv, clock: () => number): Promise<void>;