@astrosheep/square 0.3.62 → 0.3.64

package/dist/runtime.js

@@ -1,43 +1,19 @@
 import { audienceIncludes, audienceOf, fold, formatActivityId, replayLandedAudiences } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
-function parseIntegerEnvValue(name, raw, fallback) {
-    if (raw === undefined)
-        return fallback;
-    const value = parseInt(raw, 10);
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new SquareError('invalid_args', `Invalid ${name}: expected a positive integer.`);
-    }
-    return value;
-}
 function parseIntegerEnv(name, fallback) {
-    return parseIntegerEnvValue(name, process.env[name], fallback);
-}
-function parseIntegerEnvAlias(primary, aliases, fallback) {
-    const candidates = [primary, ...aliases];
-    for (const name of candidates) {
-        if (process.env[name] !== undefined)
-            return parseIntegerEnvValue(name, process.env[name], fallback);
-    }
-    return fallback;
-}
-function parseScaleEnv(name, fallback) {
     const raw = process.env[name];
     if (raw === undefined)
         return fallback;
-    const value = parseFloat(raw);
+    const value = parseInt(raw, 10);
     if (!Number.isFinite(value) || value <= 0) {
-        throw new SquareError('invalid_args', `Invalid ${name}: expected a positive number.`);
+        throw new SquareError('invalid_args', `Invalid ${name}: expected a positive integer.`);
     }
     return value;
 }
-function scaledMs(baseMs, scale) {
-    return Math.max(1, Math.round(baseMs * scale));
-}
 export const WATCH_HEARTBEAT_MS = parseIntegerEnv('SQUARE_WATCH_HEARTBEAT_MS', 60000);
-export const SLEEP_MS = parseIntegerEnvAlias('SQUARE_WATCH_POLL_MS', ['SQUARE_SLEEP_MS'], scaledMs(WATCH_HEARTBEAT_MS, parseScaleEnv('SQUARE_WATCH_POLL_SCALE', 1 / 6)));
-export const STALE_MS = parseIntegerEnvAlias('SQUARE_WATCH_QUIET_MS', ['SQUARE_STALE_MS'], scaledMs(WATCH_HEARTBEAT_MS, parseScaleEnv('SQUARE_WATCH_QUIET_SCALE', 5)));
-export const WATCH_STALE_MS = parseIntegerEnv('SQUARE_WATCH_STALE_MS', scaledMs(WATCH_HEARTBEAT_MS, parseScaleEnv('SQUARE_WATCH_STALE_SCALE', 3)));
-export const LOCK_RETRY_MS = parseIntegerEnv('SQUARE_LOCK_RETRY_MS', 25);
+export const SLEEP_MS = parseIntegerEnv('SQUARE_WATCH_POLL_MS', 10000);
+export const STALE_MS = parseIntegerEnv('SQUARE_WATCH_QUIET_MS', 300000);
+export const WATCH_STALE_MS = parseIntegerEnv('SQUARE_WATCH_STALE_MS', 180000);
 export const THROTTLE_WINDOW_MS = parseIntegerEnv('SQUARE_THROTTLE_WINDOW_MS', 60000);
 export const UNREAD_BLOCK_GRACE_MS = parseIntegerEnv('SQUARE_UNREAD_BLOCK_GRACE_MS', 90000);
 /** A held express waits for the hand to lower, but not forever: past this budget it gives up exactly like --no-wait (draft saved, retry printed). 0 disables waiting. */
@@ -71,10 +47,6 @@ export function inSquareCount(squareState) {
 export function resolveRosterName(squareState, name) {
     return findParticipantName(rosterNames(squareState), name);
 }
-export function hasQuorum(squareState, name, outs) {
-    const peers = rosterNames(squareState).filter((participant) => !sameName(participant, name));
-    return peers.length > 0 && peers.every((peer) => outs.has(nameKey(peer)));
-}
 export function countSays(acts, name) {
     return acts.filter((act) => act.kind === 'say' && sameName(act.actor, name)).length;
 }
@@ -96,12 +68,10 @@ export function sayNumberFor(acts, target) {
 export function watchTerminalStatus(squareState, name) {
     if (squareState.hardCap !== null && countSays(squareState.acts, name) >= squareState.hardCap)
         return 'capped';
-    const done = doneNames(squareState.acts);
+    const done = new Set(fold(squareState.acts).done.map((participant) => nameKey(participant)));
     done.delete(nameKey(name));
-    return hasQuorum(squareState, name, done) ? 'quorum' : undefined;
-}
-export function doneNames(acts) {
-    return new Set(fold(acts).done.map((participant) => nameKey(participant)));
+    const peers = rosterNames(squareState).filter((participant) => !sameName(participant, name));
+    return peers.length > 0 && peers.every((peer) => done.has(nameKey(peer))) ? 'quorum' : undefined;
 }
 export function joinedNames(acts) {
     return new Set(acts.filter((act) => act.kind === 'join').map((act) => nameKey(act.actor)));
@@ -127,13 +97,9 @@ export function actId(actOrIndex) {
     const index = typeof actOrIndex === 'number' ? actOrIndex : actStableIndex(actOrIndex);
     return formatActivityId(index);
 }
-function observationRecipient(squareState, name) {
+function canonicalRuntimeName(squareState, name) {
     return resolveRosterName(squareState, name) ?? name;
 }
-function observationMap(squareState, name) {
-    const key = observationRecipient(squareState, name);
-    return squareState.runtime.observations?.[key] ?? {};
-}
 export function currentHold(acts) {
     const hold = fold(acts).hold;
     return hold.active ? { active: true, at: hold.at, reason: hold.reason } : { active: false };
@@ -141,16 +107,10 @@ export function currentHold(acts) {
 export function publicActs(acts) {
     return acts.filter((act) => act.kind === 'say' || act.kind === 'done');
 }
-function canonicalRuntimeName(squareState, name) {
-    return resolveRosterName(squareState, name) ?? name;
-}
-export function observationFor(squareState, name, index) {
-    return observationMap(squareState, name)[formatActivityId(index)];
-}
 export function recordObservation(squareState, name, index, state, at = Date.now()) {
     if (!Number.isSafeInteger(index) || index < 0 || !Number.isFinite(at))
         return false;
-    const key = observationRecipient(squareState, name);
+    const key = canonicalRuntimeName(squareState, name);
     const id = formatActivityId(index);
     const current = squareState.runtime.observations[key]?.[id];
     if (current?.state === 'seen' || (current?.state === state && current.at >= at))
@@ -183,15 +143,14 @@ export function readCursor(squareState, name, landed = replayLandedAudiences(squ
     }
     return cursor;
 }
-export function latestActIndex(acts) {
-    return acts.reduce((max, act) => Math.max(max, act.index), -1);
-}
 /**
+ * The last public act the participant was verifiably present for, or -1 when there is no evidence.
+ *
  * "Was here" is a claim of presence, so it rides on evidence: the participant's own acts
  * and seen receipts after their latest join. Anything else — in particular acts merely
  * not addressed to them — says nothing about where they actually were.
  */
-export function presenceEvidenceCursor(squareState, name, landed = replayLandedAudiences(squareState.acts)) {
+export function presenceAnchor(squareState, name, landed = replayLandedAudiences(squareState.acts)) {
     const recipient = landed.resolveParticipant(name) ?? name;
     const boundary = landed.lastJoinIndex(recipient) ?? -1;
     if (boundary < 0)
@@ -205,15 +164,6 @@ export function presenceEvidenceCursor(squareState, name, landed = replayLandedA
             evidence = act.index;
         }
     }
-    return evidence;
-}
-/** The last public act the participant was verifiably present for, or -1 when there is no evidence. */
-export function presenceAnchor(squareState, name, landed = replayLandedAudiences(squareState.acts)) {
-    const recipient = landed.resolveParticipant(name) ?? name;
-    const boundary = landed.lastJoinIndex(recipient) ?? -1;
-    if (boundary < 0)
-        return -1;
-    const evidence = presenceEvidenceCursor(squareState, recipient, landed);
     for (let i = squareState.acts.length - 1; i >= 0; i--) {
         const event = squareState.acts[i];
         if (event.index <= boundary || event.index > evidence)
@@ -225,14 +175,11 @@ export function presenceAnchor(squareState, name, landed = replayLandedAudiences
 }
 export function freshWatchLease(squareState, name, at = Date.now()) {
     const key = canonicalRuntimeName(squareState, name);
-    const lease = watchLease(squareState, key);
+    const lease = squareState.runtime.leases[key];
     if (lease === undefined || lease.expiresAt <= at || at - lease.heartbeatAt > WATCH_STALE_MS)
         return undefined;
     return lease;
 }
-export function watchLease(squareState, name) {
-    return squareState.runtime.leases[canonicalRuntimeName(squareState, name)];
-}
 export function writeWatchLease(squareState, name, lease) {
     squareState.runtime.leases[canonicalRuntimeName(squareState, name)] = lease;
 }

package/dist/search.d.ts

@@ -1,5 +1,3 @@
-export declare function compileGrepPattern(pattern: string): RegExp;
-export declare function compileFixedPattern(pattern: string): RegExp;
 export declare function compileSearchPattern(pattern: string, fixed: boolean): RegExp;
 export interface GrepSnippet {
     before: string;

package/dist/search.js

@@ -3,10 +3,9 @@
 // the local CLI user and are not treated as a hostile multi-tenant input. Use
 // --fixed for literal text; do not claim regex mode has ReDoS protection.
 import { SquareError } from './model.js';
-function escapeRegex(pattern) {
-    return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-export function compileGrepPattern(pattern) {
+export function compileSearchPattern(pattern, fixed) {
+    if (fixed)
+        return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
     try {
         return new RegExp(pattern, 'i');
     }
@@ -15,12 +14,6 @@ export function compileGrepPattern(pattern) {
         throw new SquareError('invalid_args', `Invalid --grep regex: ${detail}`);
     }
 }
-export function compileFixedPattern(pattern) {
-    return new RegExp(escapeRegex(pattern), 'i');
-}
-export function compileSearchPattern(pattern, fixed) {
-    return fixed ? compileFixedPattern(pattern) : compileGrepPattern(pattern);
-}
 function compactWhitespace(text) {
     return text.replace(/\s+/g, ' ');
 }

package/dist/square-actions.js

@@ -1,25 +1,16 @@
-import { formatActivityId, parseActivityId } from './square-core.js';
 import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, decideAct, decideImplicitJoin, decideJoin, resolveKnownName, validateDoneBody } from './decisions.js';
 import { isSquareError, nameKey, SquareError, validateName } from './model.js';
 import { participantIdentity } from './participant-identity.js';
 import { deliverPending } from './delivery-operations.js';
 import { decideCatch } from './catch-decisions.js';
-import { claimSessionParticipant, claimSessionTakeover, releaseSessionParticipantClaim, readParticipantOwner, withOwnershipClaimLock } from './registry.js';
+import { claimSessionParticipant, claimSessionTakeover, presenceEpoch, releaseSessionParticipantClaim, readParticipantOwner } from './registry.js';
 import { assertLiveOwner, ensureLocalPresence, identityRouteDraft, processIdentity, publishIdentityRoute, retireIdentityRoute } from './participant-host.js';
 import { applyWakeRouteToState, dropEndedSessionWakeRoutesFromState, dropParticipantWakeRoutesFromState, dropSessionWakeRoutesFromState, sessionCanEndParticipant } from './routes.js';
+import { parseRequiredActivityId, toPublicActivity } from './views.js';
 function throwIfAborted(control) { if (control?.signal?.aborted)
     throw control.signal.reason ?? new Error('Operation aborted'); }
 function exposeCaught(activity, perception) {
-    if (activity.kind === 'read' || activity.actor === undefined)
-        throw new Error(`Cannot expose stored activity ${formatActivityId(activity.index)}`);
-    const result = {
-        id: formatActivityId(activity.index), at: activity.at, kind: activity.kind, actor: activity.actor,
-        mentions: activity.kind === 'say' ? activity.mentions ?? [] : [],
-        ...(activity.kind === 'say' && activity.reach !== undefined ? { reach: activity.reach } : {}),
-        ...('body' in activity && activity.body !== undefined ? { body: activity.body } : {}),
-        ...('target' in activity ? { target: activity.target } : {}),
-        ...(activity.kind === 'say' && activity.reply !== undefined ? { reply: formatActivityId(activity.reply) } : {}),
-    };
+    const result = toPublicActivity(activity);
     if (perception === 'full' || !('body' in result))
         return { ...result, perception };
     const { body: _body, ...withoutBody } = result;
@@ -82,42 +73,25 @@ function committedActivity(stored, verb) {
         throw new Error(`${verb} activity did not commit`);
     return activity;
 }
-function exposeActivity(stored) {
-    if (stored.kind === 'read' || stored.actor === undefined)
-        throw new Error(`Cannot expose stored activity ${formatActivityId(stored.index)}`);
-    return {
-        id: formatActivityId(stored.index), at: stored.at, kind: stored.kind, actor: stored.actor,
-        ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}),
-        mentions: stored.kind === 'say' ? stored.mentions ?? [] : [],
-        ...(stored.kind === 'say' && stored.reach !== undefined ? { reach: stored.reach } : {}),
-        ...('target' in stored ? { target: stored.target } : {}),
-        ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}),
-    };
-}
-function parseRequiredActivityId(id) {
-    const index = parseActivityId(id);
-    if (index === undefined)
-        throw new SquareError('invalid_args', `Invalid activity id: ${id}`);
-    return index;
-}
 export async function join(square, name, control) {
     // Rejected validation must not perform an ownership claim.
     throwIfAborted(control);
     validateName(name);
+    const hostLedger = square.hostLedger;
     const preview = await square.artifact.read(control?.signal);
     const previewDecision = decideJoin(preview.state, name, square.clock());
     if (previewDecision.joinAct === undefined) {
         // An active artifact participant is idempotent only for its current session.
         // A different owner must still pass through the registry CAS so it is refused
         // instead of silently reconnecting as a foreign session.
-        if (square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory') {
+        if (hostLedger !== undefined) {
             const identity = processIdentity(square.env ?? process.env);
-            const owner = await readParticipantOwner(square.location, previewDecision.joinedName, square.env ?? process.env);
+            const owner = await readParticipantOwner(square.location, previewDecision.joinedName, hostLedger);
             if (owner === undefined) {
                 // Keep the claim path for an active artifact whose ledger owner is not
                 // visible yet; concurrent callers must still serialize through CAS.
             }
-            else if (owner.sessionId !== identity.session) {
+            else if (owner.session !== identity.session) {
                 // Continue into the ownership claim below; it will produce the stable
                 // already_joined error without mutating the artifact.
             }
@@ -131,8 +105,8 @@ export async function join(square, name, control) {
     }
     let epoch;
     let ownershipClaim;
-    if (square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory') {
-        const claim = await claimSessionParticipant(square.location, name, square.env ?? process.env, control?.signal);
+    if (hostLedger !== undefined) {
+        const claim = await claimSessionParticipant(square.location, name, hostLedger, square.env ?? process.env, control?.signal);
         ownershipClaim = claim;
         epoch = claim?.epoch;
     }
@@ -154,18 +128,20 @@ export async function join(square, name, control) {
         }, control?.signal);
     }
     catch (error) {
-        await releaseSessionParticipantClaim(square.location, name, square.env ?? process.env, ownershipClaim).catch(() => undefined);
+        if (hostLedger !== undefined)
+            await releaseSessionParticipantClaim(hostLedger, ownershipClaim).catch(() => undefined);
         throw error;
     }
     await ensureLocalPresence(square, committed.name, epoch);
     await publishIdentityRoute(square, committed.name, epoch);
-    return { name: committed.name, activity: committed.stored === null ? null : exposeActivity(committed.stored) };
+    return { name: committed.name, activity: committed.stored === null ? null : toPublicActivity(committed.stored) };
 }
 /** End the standing participant and immediately let the caller reclaim the name. */
 export async function takeover(square, name, _oldSessionIds = [], control) {
     // Rejected validation must not perform an ownership claim.
     throwIfAborted(control);
     validateName(name);
+    const hostLedger = square.hostLedger;
     const commitLifecycle = async () => {
         throwIfAborted(control);
         const now = square.clock();
@@ -182,7 +158,7 @@ export async function takeover(square, name, _oldSessionIds = [], control) {
         }, control?.signal);
         return committed;
     };
-    if (square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory') {
+    if (hostLedger !== undefined) {
         const env = square.env ?? process.env;
         // Gate the ownership claim on the artifact's authoritative state: a takeover that cannot
         // commit its lifecycle (a name that never joined, or a standing participant that is no
@@ -190,13 +166,13 @@ export async function takeover(square, name, _oldSessionIds = [], control) {
         const { state } = await square.artifact.read(control?.signal);
         const joinedName = resolveKnownName(state, name); // invalid_args when the name never joined
         coreDone(state, joinedName, '', square.clock()); // already_done/not_joined when not standing
-        const owner = await readParticipantOwner(square.location, name, env);
+        const owner = await readParticipantOwner(square.location, name, hostLedger);
         throwIfAborted(control);
         // The claim and the artifact lifecycle are one fenced critical section: a losing or refused
         // takeover never mutates the winner, and no second takeover can interleave mid-commit.
-        const outcome = await claimSessionTakeover(square.location, name, env, {
-            expectedEpoch: owner?.epoch ?? 0,
-            expectedSession: owner?.sessionId ?? '',
+        const outcome = await claimSessionTakeover(square.location, name, hostLedger, env, {
+            expectedEpoch: presenceEpoch(owner),
+            expectedSession: owner?.session ?? '',
         }, async (claim) => {
             throwIfAborted(control);
             const committed = await commitLifecycle();
@@ -206,12 +182,12 @@ export async function takeover(square, name, _oldSessionIds = [], control) {
         }, control?.signal);
         if (outcome.status === 'busy')
             throw new SquareError('already_joined', `✕ ${participantIdentity(name)} already stands here — another session holds the name`);
-        return { name: outcome.result.name, activities: outcome.result.stored.map(exposeActivity), epoch: outcome.epoch };
+        return { name: outcome.result.name, activities: outcome.result.stored.map(toPublicActivity), epoch: outcome.epoch };
     }
     const committed = await commitLifecycle();
     await ensureLocalPresence(square, committed.name);
     await publishIdentityRoute(square, committed.name);
-    return { name: committed.name, activities: committed.stored.map(exposeActivity) };
+    return { name: committed.name, activities: committed.stored.map(toPublicActivity) };
 }
 export async function implicitJoin(square, name, control) {
     throwIfAborted(control);
@@ -238,7 +214,7 @@ export async function implicitJoin(square, name, control) {
         await retireIdentityRoute(square, committed.name);
     else if (committed.stored !== null)
         await publishIdentityRoute(square, committed.name);
-    return { name: committed.name, state: committed.state, activity: committed.stored === null ? null : exposeActivity(committed.stored) };
+    return { name: committed.name, state: committed.state, activity: committed.stored === null ? null : toPublicActivity(committed.stored) };
 }
 /** Only admission failures can advertise a safe retry; storage and post-commit
  * failures must not be mistaken for a rejected send merely by their error code. */
@@ -265,7 +241,7 @@ export async function express(square, name, body, options = {}, control) {
         const decision = rejectUnsentActivity(() => {
             const decision = decideAct(state, { name, body, force: options.force ?? false, now, mentions: options.mentions, ...(options.reach === undefined ? {} : { reach: options.reach }), ...(options.noMention === undefined ? {} : { noMention: options.noMention }), ...(reply === undefined ? {} : { reply }) });
             if (decision.type === 'blocked') {
-                const pending = decision.activitySummaries.reduce((count, summary) => count + summary.count, 0) + decision.unreadRoomChanges.length;
+                const pending = decision.activitySummaries.reduce((count, summary) => count + summary.count, 0);
                 throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending });
             }
             if (decision.type === 'held') {
@@ -284,7 +260,7 @@ export async function express(square, name, body, options = {}, control) {
             return decision;
         });
         const stored = committedActivity(storeActs(state, [decision.act]), 'express');
-        return { state, result: { stored } };
+        return { state, result: { stored, ...(decision.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: decision.replyAuthorNotHere }) } };
     }, control?.signal);
     await ensureLocalPresence(square, name);
     await publishIdentityRoute(square, name);
@@ -295,7 +271,7 @@ export async function express(square, name, body, options = {}, control) {
     else {
         delivery = { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 };
     }
-    return { activity: exposeActivity(committed.stored), delivery };
+    return { activity: toPublicActivity(committed.stored), delivery, ...(committed.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: committed.replyAuthorNotHere }) };
 }
 async function landListenerChange(square, verb, actor, target, control) {
     throwIfAborted(control);
@@ -306,7 +282,7 @@ async function landListenerChange(square, verb, actor, target, control) {
             return { result: null };
         return { state, result: committedActivity(storeActs(state, [act]), verb) };
     }, control?.signal);
-    return { activity: stored === null ? null : exposeActivity(stored) };
+    return { activity: stored === null ? null : toPublicActivity(stored) };
 }
 export function listen(square, actor, target, control) { return landListenerChange(square, 'listen', actor, target, control); }
 export function ignore(square, actor, target, control) { return landListenerChange(square, 'ignore', actor, target, control); }
@@ -318,7 +294,8 @@ async function landCore(square, verb, actor, body = '', fence = {}, control) {
     // session's route retirement, and presence cleanup share one ownership critical section.
     // A takeover finalizing between validation and commit can never be completed by a stale
     // done, and no post-lock cleanup can remove a replacement owner's fresh rows.
-    const fenced = verb === 'done' && square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory';
+    const hostLedger = verb === 'done' ? square.hostLedger : undefined;
+    const fenced = hostLedger !== undefined;
     const session = fenced ? processIdentity(square.env ?? process.env).session : undefined;
     const commitAndCleanup = async () => {
         if (verb === 'done' && !await assertLiveOwner(square, actor, fence.expectedEpoch)) {
@@ -326,7 +303,7 @@ async function landCore(square, verb, actor, body = '', fence = {}, control) {
         }
         let ownerRecords = [];
         if (fenced && session !== undefined) {
-            ownerRecords = (await square.hostLedger.listPresence({ location: square.location, participant: actor }))
+            ownerRecords = (await hostLedger.listPresence({ location: square.location, participant: actor }))
                 .filter((row) => row.session === session);
         }
         const now = square.clock();
@@ -339,16 +316,16 @@ async function landCore(square, verb, actor, body = '', fence = {}, control) {
             return { state, result };
         }, control?.signal);
         for (const ownerRecord of ownerRecords) {
-            await square.hostLedger.removePresenceIfUnchanged(ownerRecord).catch((error) => {
+            await hostLedger.removePresenceIfUnchanged(ownerRecord).catch((error) => {
                 process.stderr.write(`! host presence cleanup degraded: ${error instanceof Error ? error.message : String(error)}\n`);
             });
         }
         return stored;
     };
     const stored = fenced
-        ? await withOwnershipClaimLock(square.env ?? process.env, commitAndCleanup, control?.signal)
+        ? await hostLedger.withClaimLock(commitAndCleanup, control?.signal)
         : await commitAndCleanup();
-    return { activity: exposeActivity(stored) };
+    return { activity: toPublicActivity(stored) };
 }
 export function done(square, name, body = '', fence = {}, control) { return landCore(square, 'done', name, body, fence, control); }
 function liveClaimedParticipants(rows, sessionId) {
@@ -365,11 +342,9 @@ function liveClaimedParticipants(rows, sessionId) {
         claimed.delete(key);
     return claimed;
 }
-async function readLiveClaimedParticipants(square, location, sessionId) {
-    if (square.hostLedger === undefined)
-        return new Set();
+async function readLiveClaimedParticipants(hostLedger, location, sessionId, now) {
     try {
-        return liveClaimedParticipants(await square.hostLedger.listPresence({ location, now: square.clock() }), sessionId);
+        return liveClaimedParticipants(await hostLedger.listPresence({ location, now }), sessionId);
     }
     catch {
         return undefined;
@@ -385,23 +360,24 @@ async function readLiveClaimedParticipants(square, location, sessionId) {
  */
 export async function endOwnedSession(square, name, sessionId, expectedEpoch) {
     const location = square.location;
+    const hostLedger = square.hostLedger;
     const run = async () => {
         const now = square.clock();
         let currentSessionId;
         let ownerMatches = expectedEpoch === undefined;
         let ownerRecords = [];
         let liveParticipants = new Set();
-        if (location !== undefined && location !== 'memory' && square.hostLedger !== undefined) {
+        if (location !== undefined && location !== 'memory' && hostLedger !== undefined) {
             try {
-                const rows = await square.hostLedger.listPresence({ location, now });
+                const rows = await hostLedger.listPresence({ location, now });
                 const bindings = rows.filter((row) => nameKey(row.participant) === nameKey(name));
                 currentSessionId = bindings.find((binding) => binding.session !== sessionId)?.session
                     ?? bindings.toSorted((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0]?.session;
-                ownerRecords = rows.filter((row) => row.session === sessionId);
+                ownerRecords = rows.filter((row) => row.session === sessionId && nameKey(row.participant) === nameKey(name));
                 liveParticipants = liveClaimedParticipants(rows, sessionId);
                 if (expectedEpoch !== undefined) {
-                    const owner = await readParticipantOwner(location, name, square.env ?? process.env);
-                    ownerMatches = owner?.sessionId === sessionId && owner.epoch === expectedEpoch;
+                    const owner = await readParticipantOwner(location, name, hostLedger);
+                    ownerMatches = owner !== undefined && owner.session === sessionId && presenceEpoch(owner) === expectedEpoch;
                 }
             }
             catch {
@@ -420,24 +396,23 @@ export async function endOwnedSession(square, name, sessionId, expectedEpoch) {
                 }
             }
             if (location !== undefined && location !== 'memory') {
-                dropEndedSessionWakeRoutesFromState(state, location, sessionId, { expectedEpoch, liveParticipants, force: committed !== null });
+                dropEndedSessionWakeRoutesFromState(state, location, sessionId, { expectedEpoch, liveParticipants, force: committed !== null, participant: name });
             }
             return { state, result: committed };
         });
         if (stored !== null) {
             for (const ownerRecord of ownerRecords) {
-                await square.hostLedger.removePresenceIfUnchanged(ownerRecord).catch((error) => {
+                await hostLedger.removePresenceIfUnchanged(ownerRecord).catch((error) => {
                     process.stderr.write(`! host presence cleanup degraded: ${error instanceof Error ? error.message : String(error)}\n`);
                 });
             }
         }
         return stored;
     };
-    const fenced = location !== undefined && location !== 'memory' && square.hostLedger !== undefined;
-    const stored = fenced
-        ? await withOwnershipClaimLock(square.env ?? process.env, run)
+    const stored = hostLedger !== undefined
+        ? await hostLedger.withClaimLock(run)
         : await run();
-    return stored === null ? null : { activity: exposeActivity(stored) };
+    return stored === null ? null : { activity: toPublicActivity(stored) };
 }
 /**
  * Retire an ended session's orphan routes when no participant name is known. The
@@ -446,10 +421,11 @@ export async function endOwnedSession(square, name, sessionId, expectedEpoch) {
  */
 export async function retireEndedSessionRoutes(square, sessionId) {
     const location = square.location;
-    if (location === undefined || location === 'memory' || square.hostLedger === undefined)
+    const hostLedger = square.hostLedger;
+    if (location === undefined || hostLedger === undefined)
         return;
-    await withOwnershipClaimLock(square.env ?? process.env, async () => {
-        const liveParticipants = await readLiveClaimedParticipants(square, location, sessionId);
+    await hostLedger.withClaimLock(async () => {
+        const liveParticipants = await readLiveClaimedParticipants(hostLedger, location, sessionId, square.clock());
         await square.artifact.transact((state) => {
             dropEndedSessionWakeRoutesFromState(state, location, sessionId, { liveParticipants, force: false });
             return { state, result: undefined };

package/dist/square-application.js

@@ -3,22 +3,23 @@ import { setTimeout as sleep } from 'node:timers/promises';
 import { SquareError } from './model.js';
 import { validateDoneBody } from './decisions.js';
 import { currentHold, HELD_WAIT_BUDGET_MS } from './runtime.js';
-import { Square, openParticipant } from './square-wiring.js';
+import { Square } from './square-wiring.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { statusPresentation, participantsPresentation } from './views.js';
-import { hostLedgerForEnv, localParticipantName, localSessionIdentities, readParticipantOwner } from './registry.js';
+import { catchUp, express, ignore, listen, listening } from './square-actions.js';
+import { participantHistory, resolveParticipant, statusPresentation, participantsPresentation } from './views.js';
+import { hostLedgerForEnv, localParticipantName, localSessionIdentities, presenceEpoch, readParticipantOwner } from './registry.js';
 function requireLocation(context) {
     const selected = context.squarePath ?? context.env.SQUARE_LOCATION;
     if (selected === undefined || selected.trim() === '')
         throw new SquareError('invalid_args', 'Square application context needs a square location');
     return path.resolve(context.cwd, selected);
 }
-async function requireParticipant(context, squarePath, env = context.env) {
+async function requireParticipant(context, squarePath, hostLedger, env = context.env) {
     const selected = context.participant ?? env.SQUARE_PARTICIPANT_NAME;
     if (selected?.trim())
         return selected;
-    const discovered = await localParticipantName(squarePath, env).catch(() => undefined);
+    const discovered = await localParticipantName(squarePath, hostLedger, env).catch(() => undefined);
     if (discovered !== undefined)
         return discovered;
     throw new SquareError('invalid_args', 'Square application context needs one unambiguous participant name');
@@ -35,21 +36,22 @@ export function createSquareApplication(context) {
     async function existing(operation, control) {
         checkControl(control);
         const squarePath = location();
-        const participantName = await requireParticipant(context, squarePath, env);
-        const facade = await openParticipant({ path: squarePath, clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport }, participantName);
+        const participantName = await requireParticipant(context, squarePath, hostLedger, env);
+        const square = await openSquare(squarePath, { clock: context.clock, env, hostLedger, wakeTransport: context.wakeTransport });
         try {
+            const { name } = await resolveParticipant(square, participantName);
             checkControl(control);
-            return await operation(facade.participant);
+            return await operation(square, name);
         }
         finally {
-            await facade.close();
+            await closeOpenSquare(square);
         }
     }
     async function joined(operation, control) {
         checkControl(control);
         const square = await open();
         try {
-            return await operation(await square.join(await requireParticipant(context, square.location, env), control));
+            return await operation(await square.join(await requireParticipant(context, square.location, hostLedger, env), control));
         }
         finally {
             await square.close();
@@ -61,12 +63,12 @@ export function createSquareApplication(context) {
             const squarePath = location();
             const square = await open();
             try {
-                const participantName = await requireParticipant(context, squarePath, env);
+                const participantName = await requireParticipant(context, squarePath, hostLedger, env);
                 const before = await square.snapshot();
                 const standing = before.participants.some((item) => item.name.toLocaleLowerCase() === participantName.toLocaleLowerCase() && item.state === 'joined');
                 const identity = localSessionIdentities(env)[0];
-                const owner = standing ? await readParticipantOwner(squarePath, participantName, env).catch(() => undefined) : undefined;
-                const reconnect = standing && identity !== undefined && owner?.sessionId === identity.sessionId;
+                const owner = standing ? await readParticipantOwner(squarePath, participantName, hostLedger).catch(() => undefined) : undefined;
+                const reconnect = standing && identity !== undefined && owner?.session === identity.sessionId;
                 if (standing && owner !== undefined && identity !== undefined && !options.takeover && !reconnect) {
                     throw new SquareError('already_joined', `✕ ${participantName} already stands here — another session holds the name`, { pending: before.participants.length });
                 }
@@ -88,7 +90,7 @@ export function createSquareApplication(context) {
             while (true) {
                 checkControl(control);
                 try {
-                    const result = await existing((participant) => participant.express(body, options, control), control);
+                    const result = await existing((square, name) => express(square, name, body, options, control), control);
                     return { ...result, waited };
                 }
                 catch (error) {
@@ -125,11 +127,11 @@ export function createSquareApplication(context) {
                 }
             }
         },
-        catch(options, control) { return existing((participant) => participant.catch(options, control), control); },
+        catch(options, control) { return existing((square, name) => catchUp(square, name, options, undefined, control), control); },
         async history(query, control) {
             checkControl(control);
             if (context.participant !== undefined || env.SQUARE_PARTICIPANT_NAME !== undefined)
-                return existing((participant) => participant.history(query, control), control);
+                return existing((square, name) => participantHistory(square, name, query, control), control);
             const square = await open();
             try {
                 checkControl(control);
@@ -139,21 +141,21 @@ export function createSquareApplication(context) {
                 await square.close();
             }
         },
-        listen(target, control) { return existing((participant) => participant.listen(target, control), control); },
-        ignore(target, control) { return existing((participant) => participant.ignore(target, control), control); },
-        listening(control) { return existing((participant) => participant.listening(control), control); },
+        listen(target, control) { return existing((square, name) => listen(square, name, target, control), control); },
+        ignore(target, control) { return existing((square, name) => ignore(square, name, target, control), control); },
+        listening(control) { return existing((square, name) => listening(square, name, control), control); },
         hold(reason, control) { return joined((participant) => participant.hold(reason, control), control); },
         resume(control) { return joined((participant) => participant.resume(control), control); },
         async done(body, control) {
             validateDoneBody(body);
             const squarePath = location();
-            const participantName = await requireParticipant(context, squarePath, env);
+            const participantName = await requireParticipant(context, squarePath, hostLedger, env);
             const identity = localSessionIdentities(env)[0];
-            const owner = identity === undefined ? undefined : await readParticipantOwner(squarePath, participantName, env).catch(() => undefined);
-            if (identity !== undefined && owner?.sessionId === identity.sessionId && owner.epoch > 0) {
+            const owner = identity === undefined ? undefined : await readParticipantOwner(squarePath, participantName, hostLedger).catch(() => undefined);
+            if (identity !== undefined && owner?.session === identity.sessionId && presenceEpoch(owner) > 0) {
                 const square = await open();
                 try {
-                    return await square.doneOwnedSession(participantName, body ?? '', owner.epoch, control);
+                    return await square.doneOwnedSession(participantName, body ?? '', presenceEpoch(owner), control);
                 }
                 finally {
                     await square.close();