@astrosheep/square 0.4.0 → 0.4.2

package/dist/sqlite-square.js

@@ -5,9 +5,9 @@ import { squareLocation } from './square-location.js';
 import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { InternalSquareError, SquareError, isSquareError, nameKey, validateName } from './model.js';
-import { Channel, ChannelEndpoint, checkControl, failure, squareClock } from './channel-internal.js';
-import { channelArtifact } from './artifact.js';
-import { deliverPending } from './delivery-operations.js';
+import { checkControl, failure, squareClock } from './operation-control.js';
+import { validateMetadataMatch } from './delivery-deferral.js';
+import { flushSquarePosts, reconcileSquareDelivery, readSquareSessions, ensureInitialDeliverySession } from './square-posting.js';
 import { attentionChange, coreDone, coreListening, decideAct, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
 import { WATCH_HEARTBEAT_MS, inSquareCount, presenceAnchor } from './runtime.js';
 import { catchLimit, decideCatch, observeCatchSelection, selectCatchPage } from './catch-decisions.js';
@@ -16,17 +16,15 @@ import { expressHint } from './hints.js';
 import { asSeatRef, participantAuthority, requireJoinName, requireOwner } from './seats.js';
 import { recoveryObservation, entryPresentation, queryStatus, queryParticipants, catchPresence, parseRequiredActivityId, toPublicActivity, toPerceivedActivity, publicActivities, selectHistory, NON_READ, HISTORY_MAX_LIMIT, HISTORY_DEFAULT_LIMIT } from './views.js';
 import { sessionInboxCounts } from './inbox.js';
-import { squareIndexPath } from './square-index.js';
 import { participantIdentity } from './participant-identity.js';
 import { joinRecoveryCommand } from './presentation.js';
 import { acquireWatchLease, ownsWatchLease, pulseWatchLease, releaseWatchLease } from './wakes.js';
-import { squareWakeProjection } from './wake-preview.js';
 import { createArtifactPort, createSquare, diagnoseSquareFile, prepareSquareBuild } from './artifact.js';
 import { activityQueryFilter } from './activity-query.js';
 import { discoverSquares } from './list.js';
 import { streamSquare } from './stream.js';
 export { createSquareResourceOwner } from './artifact.js';
-export { squareClock } from './channel-internal.js';
+export { squareClock } from './operation-control.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
 export { HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT } from './views.js';
@@ -46,21 +44,20 @@ export class SqliteSquare {
     location;
     artifact;
     clock;
-    wakeTransport;
+    env;
+    closesArtifact;
     deliveryLocation;
-    channel;
-    constructor(location, artifact, clock, wakeTransport, indexPath, closesArtifact = true, deliveryLocation = location) {
+    constructor(location, artifact, clock, env, closesArtifact = true, deliveryLocation = location) {
         this.location = location;
         this.artifact = artifact;
         this.clock = clock;
-        this.wakeTransport = wakeTransport;
+        this.env = env;
+        this.closesArtifact = closesArtifact;
         this.deliveryLocation = deliveryLocation;
-        this.channel = Channel.fromPort({ location, artifact: channelArtifact(artifact), clock,
-            ...(wakeTransport === undefined ? {} : { deliverEffect: message => deliverPending({ artifact: channelArtifact(artifact),
-                    preparePresentation: squareWakeProjection(artifact), transport: wakeTransport, location: deliveryLocation,
-                    ...(message === undefined ? {} : { message }), now: clock() }) }),
-            ...(indexPath === undefined ? {} : { indexPath }), closesArtifact });
     }
+    reconcile() { return reconcileSquareDelivery(this.artifact, this.deliveryLocation, this.env, this.clock); }
+    // Posting is retryable after commit; a delivery failure cannot make a landed write unsent.
+    async flush() { await flushSquarePosts(this.artifact, this.deliveryLocation, this.env, this.clock).catch(() => undefined); }
     static async at(input, control) {
         const env = { ...(input.env ?? process.env) }, location = squareLocation({ ...input, env });
         const clock = squareClock(env, input.clock);
@@ -69,7 +66,7 @@ export class SqliteSquare {
         const artifact = borrowed ?? createArtifactPort(location, undefined, control?.signal);
         try {
             await artifact.read(facts => facts.header(), control?.signal);
-            return new SqliteSquare(location, artifact, clock, input.wakeTransport || undefined, squareIndexPath(env), borrowed === undefined, await canonicalPath(location));
+            return new SqliteSquare(location, artifact, clock, env, borrowed === undefined, await canonicalPath(location));
         }
         catch (error) {
             if (borrowed === undefined)
@@ -89,18 +86,15 @@ export class SqliteSquare {
     }
     static inMemory(input) {
         const env = { ...(input.env ?? process.env) };
-        return new SqliteSquare(`memory://${crypto.randomUUID()}`, createArtifactPort(':memory:', prepareSquareBuild(input, input.markdown)), squareClock(env, input.clock), input.wakeTransport || undefined);
+        return new SqliteSquare(`memory://${crypto.randomUUID()}`, createArtifactPort(':memory:', prepareSquareBuild(input, input.markdown)), squareClock(env, input.clock), env);
     }
-    /** Agora join composes membership and endpoint custody in one transaction. */
+    /** Join establishes membership and local producer custody in one transaction. */
     async joinSeat(name, options, control) {
         checkControl(control);
-        const last = options?.last ?? HISTORY_DEFAULT_LIMIT;
-        if (!Number.isSafeInteger(last) || last < 1 || last > HISTORY_MAX_LIMIT)
-            throw new SquareError('invalid_args', 'Join history limit must be between 1 and 100');
-        const owner = requireOwner(options?.owner), wakeAddress = options.wakeAddress, now = this.clock();
+        const owner = requireOwner(options?.owner), now = this.clock();
         const initial = !options.takeover ? undefined : (await this.artifact.read(facts => facts.participant(name)?.joined ? facts.seat(name) : undefined, control?.signal)).value;
-        const authority = initial === undefined ? { kind: 'join', participant: name, owner, wakeAddress }
-            : { kind: 'takeover', participant: initial.participant, owner, expectedGeneration: initial.generation, wakeAddress };
+        const authority = initial === undefined ? { kind: 'join', participant: name, owner }
+            : { kind: 'takeover', participant: initial.participant, owner, expectedGeneration: initial.generation };
         const committed = (await this.artifact.transactAs(authority, facts => {
             const participant = facts.participant(name)?.name ?? name;
             const current = facts.participant(participant), currentSeat = facts.seat(participant);
@@ -114,10 +108,8 @@ export class SqliteSquare {
             else if (current?.joined) {
                 if (currentSeat === undefined || currentSeat.owner !== owner)
                     throw new SquareError('already_joined', `${participantIdentity(participant)} is held by another owner; take it over explicitly`);
-                if (currentSeat.attachment === 'detached')
-                    facts.reattachSeat(asSeatRef(currentSeat), wakeAddress);
-                else if (wakeAddress !== undefined && (wakeAddress.kind !== 'paseo' || currentSeat.wakeAddress === undefined || currentSeat.wakeAddress.kind === 'paseo'))
-                    facts.updateWakeAddress(asSeatRef(currentSeat), wakeAddress);
+                if (currentSeat.attachment !== 'attached')
+                    throw new SquareError('already_joined', `${participantIdentity(participant)} is away; resume the host session first`);
                 kind = 'reconnected';
             }
             if (kind !== 'reconnected') {
@@ -128,12 +120,11 @@ export class SqliteSquare {
             }
             const seat = facts.seat(participant);
             if (seat === undefined)
-                throw new SquareError('invalid_args', 'The join activity did not establish its artifact endpoint.');
+                throw new SquareError('invalid_args', 'The join activity did not establish participant custody.');
             return { seat, activity, kind,
                 ...(!options.observe ? {} : { observation: { ...this.observation(inSquareCount(facts), seat.participant, now),
-                        deliveryAvailable: seat.wakeAddress !== undefined } }) };
+                        deliveryAvailable: false } }) };
         }, control?.signal)).value;
-        await this.channel.remember(owner);
         return committed;
     }
     async requiredSeat(name, { owner }) {
@@ -143,10 +134,10 @@ export class SqliteSquare {
             const participant = facts.participant(name), seat = facts.seat(name);
             if (!participant?.joined || seat === undefined || seat.owner !== owner || seat.attachment !== 'attached') {
                 const reason = participant === undefined ? 'has never stepped into this square'
-                    : !participant.joined ? 'needs a current attached endpoint; join first'
+                    : !participant.joined ? 'needs to join first'
                         : seat !== undefined && seat.owner !== owner ? 'is not held by this owner; join before writing'
-                            : seat?.attachment === 'detached' ? 'is away — join again before writing'
-                                : 'needs a current attached endpoint; join first';
+                            : seat?.attachment === 'detached' ? 'is away; resume the host session first'
+                                : 'needs a current participant seat; join first';
                 throw new SquareError('already_joined', `${participantIdentity(participant?.name ?? name)} ${reason}`, {
                     reason: 'needs_seat', join: joinRecoveryCommand(this.location, participant?.name ?? name),
                 });
@@ -154,53 +145,6 @@ export class SqliteSquare {
             return seat;
         })).value;
     }
-    async reattachSeat(name, { owner, wakeAddress }, control) {
-        checkControl(control);
-        validateName(name);
-        requireOwner(owner);
-        const captured = (await this.artifact.read(facts => facts.seat(name), control?.signal)).value;
-        if (captured === undefined || captured.owner !== owner)
-            return null;
-        const seat = (await this.artifact.transactAs({ kind: 'join', participant: name, owner, wakeAddress }, facts => {
-            const current = facts.seat(name);
-            if (!facts.participant(name)?.joined || current === undefined || current.generation !== captured.generation || current.owner !== owner)
-                return null;
-            if (current.attachment === 'detached')
-                facts.reattachSeat(asSeatRef(current), wakeAddress);
-            else if (wakeAddress !== undefined && (wakeAddress.kind !== 'paseo' || current.wakeAddress === undefined || current.wakeAddress.kind === 'paseo'))
-                facts.updateWakeAddress(asSeatRef(current), wakeAddress);
-            return facts.seat(name);
-        }, control?.signal)).value;
-        if (seat !== null)
-            await this.channel.remember(owner);
-        return seat;
-    }
-    async endHeldSeat(name, identity) {
-        const captured = (await this.artifact.read(facts => {
-            const seat = facts.seat(name);
-            return seat?.generation === identity.generation && seat.owner === identity.owner ? seat : undefined;
-        })).value;
-        if (captured === undefined)
-            return null;
-        return (await this.artifact.transactAs({ kind: 'host-cleanup', seat: captured }, facts => {
-            const current = facts.seat(name);
-            if (current === undefined || current.generation !== captured.generation || current.owner !== captured.owner)
-                return null;
-            return { activity: toPublicActivity(facts.land(coreDone(facts, current.participant, '', this.clock()))) };
-        })).value;
-    }
-    async cancelHeld(name, identity) {
-        const captured = (await this.artifact.read(facts => {
-            const seat = facts.seat(name);
-            return seat?.generation === identity.generation && seat.owner === identity.owner ? seat : undefined;
-        })).value;
-        if (captured === undefined)
-            return false;
-        return (await this.artifact.transactAs({ kind: 'participant', seat: captured }, facts => {
-            const boundary = facts.channel.header().lastMessageIndex;
-            return boundary < 0 ? false : facts.channel.cancelThrough(captured, boundary);
-        })).value;
-    }
     observation(standingCount, participant, now = this.clock()) {
         return { location: this.location, standingCount, now,
             ...(participant === undefined ? {} : { participant }) };
@@ -208,6 +152,28 @@ export class SqliteSquare {
     async contextObservation(participant, control) {
         return (await this.artifact.read(facts => this.observation(inSquareCount(facts), participant), control?.signal)).value;
     }
+    /** Host liveness is a read-only, non-atomic overlay; it never changes membership. */
+    async withHostPresence(select, control) {
+        const seats = (await this.artifact.read(facts => facts.roster().filter(person => person.joined)
+            .flatMap(person => { const seat = facts.seat(person.name); return seat === undefined ? [] : [seat]; }), control?.signal)).value;
+        const sessions = await readSquareSessions(seats, this.env);
+        const captured = new Map(seats.map(seat => [nameKey(seat.participant), seat]));
+        return (await this.artifact.read(facts => {
+            const seat = (name) => {
+                const current = facts.seat(name);
+                if (current === undefined)
+                    return undefined;
+                const before = captured.get(nameKey(current.participant));
+                const attached = before?.owner === current.owner && before.generation === current.generation
+                    && sessions.get(current.owner)?.state === 'attached';
+                return { ...current, attachment: attached ? 'attached' : 'detached' };
+            };
+            return select(Object.assign({}, facts, { seat }), name => {
+                const current = seat(name);
+                return current?.attachment === 'attached' && (sessions.get(current.owner)?.routes.length ?? 0) > 0;
+            });
+        }, control?.signal)).value;
+    }
     handle(seat) { return new SqliteSquare.ParticipantHandle(seat.participant, this, seat); }
     // The nested handle uses its resource's private dependencies without copying
     // them into a second context.
@@ -215,14 +181,12 @@ export class SqliteSquare {
         name;
         owner;
         seat;
-        endpoint;
         constructor(name, owner, seat) {
             this.name = name;
             this.owner = owner;
             this.seat = seat;
-            this.endpoint = new ChannelEndpoint(owner.channel, seat);
         }
-        get generation() { return this.endpoint.generation; }
+        get generation() { return this.seat.generation; }
         async express(bodyOrInput, optionsOrControl = {}, operationControl) {
             const square = this.owner;
             const input = typeof bodyOrInput === 'object' && bodyOrInput !== null ? bodyOrInput : undefined;
@@ -233,12 +197,14 @@ export class SqliteSquare {
             let landedId;
             try {
                 checkControl(control);
+                await square.reconcile();
                 name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
                 const seat = this.seat;
                 const context = !options.observe ? undefined : (await square.artifact.read(facts => expressionContext(facts, name), control?.signal)).value;
                 while (true) {
                     checkControl(control);
                     try {
+                        await square.reconcile();
                         effect = 'unknown';
                         const now = square.clock();
                         const reply = rejectUnsentActivity(() => {
@@ -267,21 +233,17 @@ export class SqliteSquare {
                                 return proposed;
                             });
                             const stored = facts.land(decision.act);
-                            // One explicit projection: a landed say resolves its own Channel content in this transaction.
-                            const activity = stored.kind === 'say' ? facts.activities([stored.index])[0] : stored;
-                            if (activity === undefined)
-                                throw new SquareError('io', 'The landed activity is missing.');
-                            return { stored, activity, standingCount: inSquareCount(facts),
+                            return { stored, standingCount: inSquareCount(facts),
                                 ownActivityCount: facts.participant(name).sayCount, hardCap: facts.header().hardCap,
                                 ...(decision.unmatchedMentions === undefined ? {} : { unmatchedMentions: decision.unmatchedMentions }),
                                 ...(decision.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: decision.replyAuthorNotHere }) };
                         }, control?.signal)).value;
                         landedId = formatActivityId(committed.stored.index);
                         effect = 'landed';
-                        await square.channel.deliver(committed.stored.kind === 'say' ? committed.stored.messageIndex : undefined);
-                        const { stored, activity, standingCount, ownActivityCount, hardCap, ...metadata } = committed;
+                        await square.flush();
+                        const { stored, standingCount, ownActivityCount, hardCap, ...metadata } = committed;
                         const hint = expressHint(ownActivityCount);
-                        return { activity: toPublicActivity(activity), ...metadata,
+                        return { activity: toPublicActivity(stored), ...metadata,
                             ...(hint === undefined ? {} : { hint }), ...(context === undefined ? {} : { observation: {
                                     ...square.observation(standingCount, name, now), ownActivityCount, hardCap, context, participant: name,
                                 } }) };
@@ -304,10 +266,11 @@ export class SqliteSquare {
         }
         async listener(verb, target, options, control) {
             const square = this.owner;
-            const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             checkControl(control);
+            await square.reconcile();
+            const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             const seat = this.seat, now = square.clock();
-            return (await square.artifact.transactAs(participantAuthority(seat), facts => {
+            const result = (await square.artifact.transactAs(participantAuthority(seat), facts => {
                 const act = attentionChange(facts, verb, name, target, now);
                 const activity = act === undefined ? null : toPublicActivity(facts.land(act));
                 return { activity, ...(!options.observe ? {} : { observation: {
@@ -315,6 +278,8 @@ export class SqliteSquare {
                             target: activity?.target ?? target,
                         } }) };
             }, control?.signal)).value;
+            await square.flush();
+            return result;
         }
         listen(target, options = {}, control) { return this.listener('listen', target, options, control); }
         ignore(target, options = {}, control) { return this.listener('ignore', target, options, control); }
@@ -328,6 +293,7 @@ export class SqliteSquare {
         }
         /** Receipt selection rechecks the lease inside the writer, not at its last heartbeat. */
         async catchPage(name, seat, options, control, leaseId) {
+            await this.owner.reconcile();
             return (await this.owner.artifact.transactAs(participantAuthority(seat), facts => {
                 if (leaseId !== undefined && facts.lease(name)?.leaseId !== leaseId)
                     return null;
@@ -346,27 +312,35 @@ export class SqliteSquare {
                 }, square.clock()))).value;
                 if (reason === 'drained')
                     reason = view.terminalStatus ?? reason;
+                await square.flush();
                 if (leaseId !== undefined) {
                     await releaseWatchLease(square.artifact, seat, leaseId).catch(() => undefined);
                     leaseId = undefined;
                 }
-                let presence;
+                let presence, deliveryAvailable = false;
                 if (options.observe) {
                     try {
-                        presence = (await square.artifact.read(facts => catchPresence(facts, square.clock()), control?.signal)).value;
+                        const observed = await square.withHostPresence((facts, available) => {
+                            const data = catchPresence(facts, square.clock());
+                            return { presence: { ...data, participants: data.participants.map(person => ({ ...person, deliveryAvailable: available(person.name) })) },
+                                deliveryAvailable: available(view.participant) };
+                        }, control);
+                        presence = observed.presence;
+                        deliveryAvailable = observed.deliveryAvailable;
                     }
                     catch { /* Optional presence cannot erase the completed selection or receipts. */ }
                 }
                 return { activities: view.activities, remaining: view.remaining, reason,
                     ...(view.hint === undefined ? {} : { hint: view.hint }), ...(!options.observe ? {} : { observation: {
                             ...square.observation(view.standingCount, view.participant, view.now), participant: view.participant,
-                            deliveryAvailable: view.deliveryAvailable,
+                            deliveryAvailable,
                             ownActivityCount: view.ownActivityCount, hardCap: view.hardCap,
                             ...(presence === undefined ? { enrichmentUnavailable: true } : { presence }),
                         } }) };
             };
             try {
                 checkControl(control);
+                await square.reconcile();
                 validateName(name);
                 if (!Number.isFinite(idle) || idle < 0)
                     throw new SquareError('invalid_args', 'Catch idle duration must be a non-negative number');
@@ -441,7 +415,7 @@ export class SqliteSquare {
             const limit = options.limit === undefined ? 100 : options.limit;
             if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
                 throw new SquareError('invalid_args', 'Pending limit must be a positive integer no greater than 100.');
-            // Pending follows the shared archive cursor: act/N with before/after, never a Channel msg/N cursor.
+            // Pending follows the shared archive cursor: act/N with before/after.
             const shared = activityQueryFilter(options);
             const filter = { kinds: ['say'], unseenOnly: true,
                 ...(shared.indexes === undefined ? {} : { indexes: shared.indexes }),
@@ -457,45 +431,52 @@ export class SqliteSquare {
                     remaining: facts.directedCount(this.name, filter) - heads.items.length };
             }, control?.signal)).value;
         }
-        ack(ids, control) {
+        ack(input, control) {
             const square = this.owner;
+            checkControl(control);
             return square.artifact.transactAs(participantAuthority(this.seat), facts => {
+                if (!Array.isArray(input)) {
+                    const exact = input;
+                    if (exact?.future !== 'exact')
+                        throw new SquareError('invalid_args', 'Ack requires an exact future predicate.');
+                    validateName(exact.from);
+                    return { consumed: facts.ackMatching(asSeatRef(this.seat), { from: exact.from, match: validateMetadataMatch(exact.match), future: 'exact' }, square.clock()) };
+                }
                 const indexes = [];
-                for (const id of ids) {
+                for (const id of input) {
                     const activity = facts.activity(parseRequiredActivityId(id));
-                    if (activity?.kind !== 'say' || activity.messageIndex === undefined)
+                    if (activity?.kind !== 'say')
                         throw new SquareError('invalid_args', `${id} is not addressed to you.`, { reason: 'not_addressed', activityId: id });
                     const head = facts.directed(this.name, { indexes: [activity.index], kinds: ['say'] }, { edge: 'oldest', limit: 1 }).items[0];
                     if (head === undefined)
                         throw new SquareError('invalid_args', `${id} is not addressed to you.`, { reason: 'not_addressed', activityId: id });
-                    indexes.push(activity.messageIndex);
+                    indexes.push(activity.index);
                 }
-                return { consumed: facts.channel.markSeen(this.name, indexes, square.clock()) };
+                return { consumed: facts.markSeen(this.name, indexes, square.clock()) };
             }, control?.signal).then(result => result.value);
         }
-        deferDelivery(input, control) {
-            return this.endpoint.deferDelivery(input, control);
-        }
-        renewDeliveryDeferral(id, durationMs, control) {
-            return this.endpoint.renewDeliveryDeferral(id, durationMs, control);
-        }
-        releaseDeliveryDeferral(id, control) {
-            return this.endpoint.releaseDeliveryDeferral(id, control);
-        }
         async done(body, options = {}, control) {
             validateDoneBody(body);
+            checkControl(control);
             const square = this.owner;
+            await square.reconcile();
             const name = (await square.artifact.read(facts => resolveKnownName(facts, this.name), control?.signal)).value;
             const seat = this.seat, now = square.clock();
-            return (await square.artifact.transactAs(participantAuthority(seat), facts => {
+            const result = (await square.artifact.transactAs(participantAuthority(seat), facts => {
                 const stored = facts.land(coreDone(facts, name, body ?? '', now));
                 return { activity: toPublicActivity(stored), ...(!options.observe ? {} : { observation: square.observation(inSquareCount(facts), name, now),
                     }) };
             }, control?.signal)).value;
+            await square.flush();
+            return result;
         }
     };
-    send(input, control) {
-        return this.channel.send(input, control);
+    async send(input, control) {
+        checkControl(control);
+        await this.reconcile();
+        const result = (await this.artifact.transactAs({ kind: 'send', actor: input.from }, facts => facts.insertNotice(input, this.clock()), control?.signal)).value;
+        await this.flush();
+        return result;
     }
     async participant(name, options) {
         return this.handle(await this.requiredSeat(name, options));
@@ -505,28 +486,36 @@ export class SqliteSquare {
         try {
             checkControl(control);
             name = requireJoinName(requested);
+            const last = options.last ?? HISTORY_DEFAULT_LIMIT;
+            if (!Number.isSafeInteger(last) || last < 1 || last > HISTORY_MAX_LIMIT)
+                throw new SquareError('invalid_args', 'Join history limit must be between 1 and 100');
+            if (!await ensureInitialDeliverySession(requireOwner(options.owner), this.env, options.wakeAddress))
+                throw new SquareError('already_joined', `${participantIdentity(name)} is away; resume the host session first`, { reason: 'needs_seat' });
+            await this.reconcile();
             const committed = await this.joinSeat(name, options, control);
+            await this.flush();
             const participant = this.handle(committed.seat);
             const result = { participant, activity: committed.activity, kind: committed.kind,
                 ...(committed.observation === undefined ? {} : { observation: committed.observation }) };
             if (!options.observe)
                 return result;
-            let entry;
+            let entry, deliveryAvailable = false;
             try {
-                entry = (await this.artifact.read(facts => entryPresentation(facts, participant.name, options.last ?? HISTORY_DEFAULT_LIMIT), control?.signal)).value;
+                const observed = await this.withHostPresence((facts, available) => ({
+                    entry: entryPresentation(facts, participant.name, options.last ?? HISTORY_DEFAULT_LIMIT),
+                    deliveryAvailable: available(participant.name),
+                }), control);
+                entry = observed.entry;
+                deliveryAvailable = observed.deliveryAvailable;
             }
             catch { /* Keep the committed join even when optional history is unavailable. */ }
-            return { ...result, observation: { ...committed.observation,
+            return { ...result, observation: { ...committed.observation, deliveryAvailable,
                     ...(entry === undefined ? { enrichmentUnavailable: true } : { entry }) } };
         }
         catch (error) {
             throw failure(error, { operation: 'join', subject: 'caller', participant: name });
         }
     }
-    async reattach(name, { owner, wakeAddress }, control) {
-        const seat = await this.reattachSeat(name, { owner, wakeAddress }, control);
-        return seat === null ? null : this.handle(seat);
-    }
     async history(query = {}, control) {
         if (query.limit !== undefined && query.limit !== null && (!Number.isSafeInteger(query.limit) || query.limit < 1 || query.limit > HISTORY_MAX_LIMIT))
             throw new SquareError('invalid_args', `History limit must be a positive integer no greater than ${HISTORY_MAX_LIMIT}`);
@@ -558,12 +547,22 @@ export class SqliteSquare {
         }, control?.signal)).value;
     }
     async status(options = {}, control) {
-        return (await this.artifact.read(facts => queryStatus(facts, { location: this.location, now: this.clock() }, options.viewer, options.observe === true), control?.signal)).value;
+        return this.withHostPresence((facts, available) => {
+            const result = queryStatus(facts, { location: this.location, now: this.clock() }, options.viewer, options.observe === true);
+            return { ...result, participants: result.participants.map(person => ({ ...person, deliveryAvailable: available(person.name) })) };
+        }, control);
     }
+    /** Local mode reads only World-known facts; it does not verify host attachment. */
     async participants(options = {}, control) {
-        return (await this.artifact.read(facts => queryParticipants(facts, {
-            location: this.location, now: this.clock(),
-        }, options.observe === true), control?.signal)).value;
+        if (options.local)
+            return (await this.artifact.read(facts => {
+                const result = queryParticipants(facts, { location: this.location, now: this.clock() }, options.observe === true);
+                return { ...result, participants: result.participants.map(person => ({ ...person, deliveryAvailable: false })) };
+            }, control?.signal)).value;
+        return this.withHostPresence((facts, available) => {
+            const result = queryParticipants(facts, { location: this.location, now: this.clock() }, options.observe === true);
+            return { ...result, participants: result.participants.map(person => ({ ...person, deliveryAvailable: available(person.name) })) };
+        }, control);
     }
     async recovery(requested, control) {
         const facts = requested === undefined ? undefined : (await this.artifact.read(facts => recoveryObservation(facts, requested, this.clock()), control?.signal).catch(() => undefined))?.value;
@@ -575,18 +574,12 @@ export class SqliteSquare {
         return streamSquare(this.location, options, control);
     }
     async seatsOf(owner) {
-        return this.channel.endpointsOf(owner);
-    }
-    close() { return this.channel.close(); }
-    cancelDeliveries(name, identity) {
-        return this.cancelHeld(name, identity);
-    }
-    detach(name, identity) {
-        return this.channel.detach(name, identity);
-    }
-    endHeld(name, identity) {
-        return this.endHeldSeat(name, identity);
+        requireOwner(owner);
+        return (await this.artifact.read(facts => facts.seatsForOwner(owner)
+            .filter(seat => facts.participant(seat.participant)?.joined && seat.attachment === 'attached')
+            .map(seat => ({ name: seat.participant, generation: seat.generation })))).value;
     }
+    close() { return this.closesArtifact ? this.artifact.close() : Promise.resolve(); }
 }
 export function diagnoseSquare(input, control) { checkControl(control); return diagnoseSquareFile(squareLocation(input)); }
 export function discover(input, options = {}, control) {
@@ -598,10 +591,10 @@ export function discover(input, options = {}, control) {
 export async function inbox(input, owner, options = {}, control) {
     checkControl(control);
     requireOwner(owner);
-    const env = { ...(input.env ?? process.env) }, limit = options.limit ?? 20;
+    const limit = options.limit ?? 20;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
         throw new SquareError('invalid_args', 'Inbox limit must be between 1 and 100');
-    const rows = await sessionInboxCounts({ owner, env }, control?.signal);
+    const rows = await sessionInboxCounts({ owner, cwd: input.cwd }, control?.signal);
     checkControl(control);
     const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
     rows.sort((a, b) => compare(a.squarePath, b.squarePath) || compare(nameKey(a.name), nameKey(b.name)) || compare(a.name, b.name));

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;

package/dist/square-core.d.ts

@@ -29,7 +29,6 @@ export type Act = {
     mentions?: readonly Participant[];
     reach?: Reach;
     reply?: number;
-    messageIndex?: number;
 } | {
     kind: 'read';
     actor: Participant;

package/dist/square-domain.d.ts

@@ -1,12 +1,6 @@
-import { type ActDraft, type Seat, type StoredAct } from './model.js';
-import { type EndpointGeneration } from './message.js';
+import { type ActDraft, type Seat } from './model.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;
+import type { ProducerWrite } from './square-post.js';
 export interface LandingEffect {
     readonly activity: ActDraft & {
         readonly index: number;
@@ -23,29 +17,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 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: 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. */
+export interface LandingWriter extends Pick<SquareWrite, 'putLease' | 'removeLease' | 'markSeen' | 'setSeatAttachment'>, ProducerWrite {
     storeSeat(seat: Seat): boolean;
-    removeSeat(seat: EndpointRef): boolean;
+    removeSeat(seat: SeatRef): boolean;
     applyLanding(effect: LandingEffect): void;
-    readonly channel: ChannelWrite;
 }
 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;