@astrosheep/square 0.3.86 → 0.3.87

package/dist/routes.js

@@ -1,99 +0,0 @@
-import { nameKey } from './model.js';
-import { canonicalPath, canonicalPathSync } from './canonical-path.js';
-export { WAKE_ROUTE_KINDS } from './model.js';
-export const ROUTE_FRESH_MS = 24 * 60 * 60 * 1000;
-export async function defaultWakeRouteCapabilities(hostLedger) {
-    const available = new Set();
-    try {
-        const { CodexQueueAdapter } = await import('./codex-queue.js');
-        available.add(new CodexQueueAdapter().kind);
-    }
-    catch { /* optional */ }
-    try {
-        const { PaseoAdapter } = await import('./paseo-delivery.js');
-        available.add(new PaseoAdapter().kind);
-    }
-    catch { /* optional */ }
-    return { canUse: (kind, address) => hostLedger !== undefined && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
-}
-export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
-    const paseoAgentId = env.PASEO_AGENT_ID?.trim();
-    const candidates = [];
-    if (boundary.provider === 'codex')
-        candidates.push({ kind: 'codex-queue', address: { threadId: boundary.sessionId } });
-    if (paseoAgentId)
-        candidates.push({ kind: 'paseo', address: { agentId: paseoAgentId } });
-    const chosen = candidates.find((candidate) => Object.values(candidate.address).every((value) => value.trim() !== '') && capabilities.canUse(candidate.kind, candidate.address));
-    return chosen === undefined ? undefined : { location: boundary.location, participant: boundary.participant, sessionId: boundary.sessionId, channel: boundary.provider === 'paseo' ? 'paseo' : boundary.provider === 'claude' ? 'claude-code' : boundary.provider, ...chosen };
-}
-export function routeIdentityKey(route, location = route.location) {
-    return JSON.stringify([location, nameKey(route.participant), route.sessionId]);
-}
-function sameRouteAddress(left, right) {
-    const leftKeys = Object.keys(left).sort();
-    const rightKeys = Object.keys(right).sort();
-    return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => rightKeys[index] === key && left[key] === right[key]);
-}
-export function applyWakeRoute(facts, route, at = Date.now()) {
-    const location = canonicalPathSync(route.location);
-    const identity = routeIdentityKey(route, location);
-    facts.replaceRoutes([...facts.routes().filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== identity),
-        { ...route, location, updatedAt: at, extra: {} }]);
-}
-export function dropSessionWakeRoutes(facts, location, sessionId, expectedEpoch) {
-    const canonical = canonicalPathSync(location);
-    facts.replaceRoutes(facts.routes().filter((item) => item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical
-        || (expectedEpoch !== undefined && item.epoch !== expectedEpoch)));
-}
-/** Keep an in-flight same-session rejoin; unknown host evidence is not a reason to retire it. */
-export function dropEndedSessionWakeRoutes(facts, location, sessionId, opts) {
-    const canonical = canonicalPathSync(location);
-    facts.replaceRoutes(facts.routes().filter((item) => {
-        if (item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical)
-            return true;
-        if (opts.participant !== undefined && nameKey(item.participant) !== nameKey(opts.participant))
-            return true;
-        if (!opts.force && facts.participant(item.participant)?.joined
-            && (opts.liveParticipants === undefined || opts.liveParticipants.has(nameKey(item.participant))))
-            return true;
-        return opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch;
-    }));
-}
-export function dropParticipantWakeRoutes(facts, location, participant) {
-    const canonical = canonicalPathSync(location);
-    facts.replaceRoutes(facts.routes().filter((item) => !(nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical)));
-}
-export function sessionCanEndParticipant(facts, location, participant, sessionId, sessionIdNow) {
-    const canonical = canonicalPathSync(location);
-    const owned = facts.routes().filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical);
-    if (owned.length === 0)
-        return sessionIdNow === sessionId;
-    return owned.every((item) => item.sessionId === sessionId) && (sessionIdNow === undefined || sessionIdNow === sessionId);
-}
-export async function publishWakeRoute(artifact, route, opts = {}) {
-    const location = await canonicalPath(route.location);
-    const at = opts.at ?? Date.now();
-    await artifact.transact((facts) => {
-        const routes = facts.routes();
-        if (opts.requireCurrentSession && (!facts.participant(route.participant)?.joined
-            || routes.some((item) => nameKey(item.participant) === nameKey(route.participant) && canonicalPathSync(item.location) === location && item.sessionId !== route.sessionId)))
-            return;
-        const identity = routeIdentityKey(route, location);
-        const matching = routes.filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) === identity);
-        // A receiver's fresh native registration outranks a generic Paseo proposal.
-        // Arbitrate in the write transaction so tool publication and mod reconciliation cannot flip it back.
-        if (route.kind === 'paseo' && matching.some((item) => item.kind !== 'paseo' && item.channel === route.channel
-            && item.epoch === route.epoch && item.updatedAt <= at && item.updatedAt > at - ROUTE_FRESH_MS))
-            return;
-        const existing = matching[0];
-        if (matching.length === 1 && existing.updatedAt > at - ROUTE_FRESH_MS && existing.kind === route.kind
-            && existing.channel === route.channel && sameRouteAddress(existing.address, route.address) && existing.epoch === route.epoch)
-            return;
-        applyWakeRoute(facts, { ...route, location }, at);
-    });
-}
-export async function retireWakeRouteFromArtifact(artifact, route, opts = {}) {
-    const location = await canonicalPath(route.location);
-    const target = routeIdentityKey(route, location);
-    await artifact.transact((facts) => facts.replaceRoutes(facts.routes().filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== target || (opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch))));
-}

package/dist/square-actions.d.ts

@@ -1,56 +0,0 @@
-import { type StoredAct } from './model.js';
-import type { WakeTransportPort } from './ports.js';
-import type { Activity, ActivityResult, CatchOptions, ExpressOptions, ExpressResult, ExpressionObservation, OperationControl, OwnershipFenceOptions, SquareObservation } from './square-facade.js';
-import { type CatchSelection } from './catch-decisions.js';
-import { type HostContext } from './participant-host.js';
-export interface OperationContext extends HostContext {
-    readonly wakeTransport?: WakeTransportPort;
-}
-export type { OwnershipFenceOptions };
-export declare function catchUp(square: OperationContext, name: string, options?: CatchOptions, control?: OperationControl): Promise<CatchSelection>;
-export declare function catchUp(square: OperationContext, name: string, options: CatchOptions, control: OperationControl | undefined, leaseId: string): Promise<CatchSelection | null>;
-type LandingContext = Pick<SquareObservation, 'standingCount' | 'held' | 'now'>;
-export declare function join(square: OperationContext, name: string, control?: OperationControl, admission?: {
-    readonly requireKnown?: boolean;
-}): Promise<{
-    readonly name: string;
-    readonly activity: Activity | null;
-    readonly participantCount: number;
-    readonly reconnected: boolean;
-    readonly observation: LandingContext;
-}>;
-/** Takeover holds the host CAS fence across the single done+join artifact transaction. */
-export declare function takeover(square: OperationContext, name: string, control?: OperationControl): Promise<{
-    readonly name: string;
-    readonly activities: readonly Activity[];
-    readonly participantCount: number;
-    readonly epoch?: number;
-    readonly observation: LandingContext;
-}>;
-export declare function implicitJoin(square: OperationContext, name: string, control?: OperationControl): Promise<{
-    readonly name: string;
-    readonly state: 'joined' | 'active' | 'done';
-    readonly activity: Activity | null;
-}>;
-export interface ExpressCommittedResult extends Omit<ExpressResult, 'waited' | 'observation'> {
-    readonly observation: ExpressionObservation;
-}
-export declare function express(square: OperationContext, name: string, body: string, options?: ExpressOptions, control?: OperationControl): Promise<ExpressCommittedResult>;
-export interface ListenerCommittedResult {
-    readonly activity: Activity | null;
-    readonly observation: LandingContext;
-}
-export declare function listen(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
-export declare function ignore(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
-export declare function unlisten(square: OperationContext, actor: string, target: string, control?: OperationControl): Promise<ListenerCommittedResult>;
-export declare function listening(square: OperationContext, actor: string, control?: OperationControl): Promise<readonly string[]>;
-export interface LifecycleCommittedResult extends ActivityResult {
-    readonly observation: LandingContext & {
-        readonly activity: StoredAct;
-    };
-}
-export declare function done(square: OperationContext, name: string, body?: string, fence?: OwnershipFenceOptions, control?: OperationControl): Promise<LifecycleCommittedResult>;
-export declare function endOwnedSession(square: OperationContext, name: string, sessionId: string, expectedEpoch?: number): Promise<ActivityResult | null>;
-export declare function retireEndedSessionRoutes(square: OperationContext, sessionId: string): Promise<void>;
-export declare function hold(square: OperationContext, name: string, reason?: string, control?: OperationControl): Promise<LifecycleCommittedResult>;
-export declare function resume(square: OperationContext, name: string, control?: OperationControl): Promise<LifecycleCommittedResult>;

package/dist/square-actions.js

@@ -1,353 +0,0 @@
-import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, coreUnlisten, 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, observeCatchSelection, selectCatchPage } from './catch-decisions.js';
-import { inSquareCount } from './runtime.js';
-import { claimSessionParticipant, claimSessionTakeover, presenceEpoch, releaseSessionParticipantClaim, readParticipantOwner } from './registry.js';
-import { assertLiveOwner, ensureLocalPresence, identityRouteDraft, processIdentity, publishCommittedIdentity, retireIdentityRoute } from './participant-host.js';
-import { applyWakeRoute, dropEndedSessionWakeRoutes, dropParticipantWakeRoutes, dropSessionWakeRoutes, 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'); }
-export async function catchUp(square, name, options = {}, control, leaseId) {
-    throwIfAborted(control);
-    if (!await assertLiveOwner(square, name))
-        throw new SquareError('already_joined', `${participantIdentity(name)} already stands here — another session holds the name`);
-    let selected;
-    if (leaseId === undefined && options.id === undefined) {
-        selected = (await square.artifact.read((facts) => {
-            const page = selectCatchPage(facts, name, options);
-            return page.indexes.length === 0 ? observeCatchSelection(facts, page.participant, [], page.filter, square.clock()) : undefined;
-        }, control?.signal)).value;
-    }
-    if (selected === undefined)
-        selected = (await square.artifact.transact((facts) => {
-            // Replacement and selection share the receipt transaction: an old waiter cannot
-            // consume a later activity between its heartbeat and its selection.
-            if (leaseId !== undefined && facts.lease(name)?.leaseId !== leaseId)
-                return null;
-            return decideCatch(facts, name, options, square.clock());
-        }, control?.signal)).value;
-    if (selected !== null)
-        await publishCommittedIdentity(square, selected.participant);
-    return selected;
-}
-export async function join(square, name, control, admission = {}) {
-    throwIfAborted(control);
-    validateName(name);
-    const hostLedger = square.hostLedger;
-    const preview = (await square.artifact.read((facts) => {
-        // Express may reenter a known participant, but must never create a new name.
-        const selected = admission.requireKnown ? resolveKnownName(facts, name) : name;
-        const now = square.clock();
-        return {
-            ...decideJoin(facts, selected, now),
-            participantCount: facts.roster().filter((p) => p.joined || p.done).length,
-            observation: { standingCount: inSquareCount(facts), held: facts.hold().active, now },
-        };
-    }, control?.signal)).value;
-    name = preview.joinedName;
-    if (preview.joinAct === undefined) {
-        if (hostLedger === undefined)
-            return { name: preview.joinedName, activity: null, participantCount: preview.participantCount, reconnected: false, observation: preview.observation };
-        const identity = processIdentity(square.env ?? process.env);
-        const owner = await readParticipantOwner(square.location, preview.joinedName, hostLedger);
-        if (owner?.session === identity.session)
-            return {
-                name: preview.joinedName, activity: null, participantCount: preview.participantCount,
-                reconnected: identity.channel !== 'unknown', observation: preview.observation,
-            };
-        // Missing or foreign owner must pass CAS, not become a silent reconnect.
-    }
-    let epoch;
-    let ownershipClaim;
-    if (hostLedger !== undefined) {
-        ownershipClaim = await claimSessionParticipant(square.location, name, hostLedger, square.env ?? process.env, control?.signal);
-        epoch = ownershipClaim?.epoch;
-    }
-    let committed;
-    try {
-        const now = square.clock(), route = await identityRouteDraft(square, name);
-        throwIfAborted(control);
-        committed = (await square.artifact.transact((facts) => {
-            const decision = decideJoin(facts, name, now);
-            if (decision.joinAct !== undefined) {
-                if (square.location !== undefined && square.location !== 'memory')
-                    dropParticipantWakeRoutes(facts, square.location, decision.joinedName);
-                if (route !== undefined)
-                    applyWakeRoute(facts, route, now);
-            }
-            const stored = decision.joinAct === undefined ? null : facts.land(decision.joinAct);
-            return {
-                name: decision.joinedName, stored,
-                participantCount: facts.roster().filter((p) => p.joined || p.done).length,
-                observation: { standingCount: inSquareCount(facts), held: facts.hold().active, now },
-            };
-        }, control?.signal)).value;
-    }
-    catch (error) {
-        if (hostLedger !== undefined)
-            await releaseSessionParticipantClaim(hostLedger, ownershipClaim).catch(() => undefined);
-        throw error;
-    }
-    await publishCommittedIdentity(square, committed.name, epoch);
-    return {
-        name: committed.name, activity: committed.stored === null ? null : toPublicActivity(committed.stored),
-        participantCount: committed.participantCount, reconnected: false, observation: committed.observation,
-    };
-}
-/** Takeover holds the host CAS fence across the single done+join artifact transaction. */
-export async function takeover(square, name, control) {
-    throwIfAborted(control);
-    validateName(name);
-    const hostLedger = square.hostLedger;
-    const commitLifecycle = async () => {
-        throwIfAborted(control);
-        const now = square.clock();
-        return (await square.artifact.transact((facts) => {
-            const joinedName = resolveKnownName(facts, name);
-            const storedDone = facts.land(coreDone(facts, joinedName, '', now));
-            const decision = decideJoin(facts, joinedName, now);
-            if (decision.joinAct === undefined)
-                throw new SquareError('already_joined', `${participantIdentity(joinedName)} could not be reclaimed`);
-            const storedJoin = facts.land(decision.joinAct);
-            facts.replaceRoutes(facts.routes().filter((route) => nameKey(route.participant) !== nameKey(joinedName)));
-            return {
-                name: joinedName, stored: [storedDone, storedJoin],
-                participantCount: facts.roster().filter((p) => p.joined || p.done).length,
-                observation: { standingCount: inSquareCount(facts), held: facts.hold().active, now },
-            };
-        }, control?.signal)).value;
-    };
-    if (hostLedger !== undefined) {
-        // Gate the claim on authoritative admission, so a refused takeover never claims presence.
-        await square.artifact.read((facts) => coreDone(facts, resolveKnownName(facts, name), '', square.clock()), control?.signal);
-        const owner = await readParticipantOwner(square.location, name, hostLedger);
-        throwIfAborted(control);
-        const outcome = await claimSessionTakeover(square.location, name, hostLedger, square.env ?? process.env, {
-            expectedEpoch: presenceEpoch(owner), expectedSession: owner?.session ?? '',
-        }, async (claim) => {
-            throwIfAborted(control);
-            const committed = await commitLifecycle();
-            await publishCommittedIdentity(square, committed.name, claim.epoch);
-            return committed;
-        }, 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(toPublicActivity), participantCount: outcome.result.participantCount, epoch: outcome.epoch, observation: outcome.result.observation };
-    }
-    const committed = await commitLifecycle();
-    await publishCommittedIdentity(square, committed.name);
-    return { name: committed.name, activities: committed.stored.map(toPublicActivity), participantCount: committed.participantCount, observation: committed.observation };
-}
-export async function implicitJoin(square, name, control) {
-    throwIfAborted(control);
-    const now = square.clock(), route = await identityRouteDraft(square, name);
-    throwIfAborted(control);
-    const committed = (await square.artifact.transact((facts) => {
-        const decision = decideImplicitJoin(facts, name, now);
-        if (decision.state === 'done') {
-            if (square.location !== undefined && square.location !== 'memory')
-                dropSessionWakeRoutes(facts, square.location, processIdentity(square.env ?? process.env).session);
-        }
-        else if (decision.joinAct !== undefined) {
-            if (square.location !== undefined && square.location !== 'memory')
-                dropParticipantWakeRoutes(facts, square.location, decision.joinedName);
-            if (route !== undefined)
-                applyWakeRoute(facts, { ...route, participant: decision.joinedName }, now);
-        }
-        return { name: decision.joinedName, state: decision.state, stored: decision.joinAct === undefined ? null : facts.land(decision.joinAct) };
-    }, control?.signal)).value;
-    if (committed.stored !== null)
-        await publishCommittedIdentity(square, committed.name);
-    else
-        await ensureLocalPresence(square, committed.name);
-    if (committed.state === 'done')
-        await retireIdentityRoute(square, committed.name);
-    return { name: committed.name, state: committed.state, activity: committed.stored === null ? null : toPublicActivity(committed.stored) };
-}
-function rejectUnsentActivity(operation) {
-    try {
-        return operation();
-    }
-    catch (error) {
-        if (isSquareError(error))
-            error.facts = { ...error.facts, activityUnsent: true };
-        throw error;
-    }
-}
-export async function express(square, name, body, options = {}, control) {
-    throwIfAborted(control);
-    if (!await assertLiveOwner(square, name))
-        throw new SquareError('already_joined', `${participantIdentity(name)} already stands here — another session holds the name`, { activityUnsent: true });
-    throwIfAborted(control);
-    const now = square.clock();
-    const reply = rejectUnsentActivity(() => {
-        try {
-            return options.reply === undefined ? undefined : parseRequiredActivityId(options.reply);
-        }
-        catch (error) {
-            if (isSquareError(error))
-                error.facts = {
-                    ...error.facts, reason: 'invalid_reply', activityId: options.reply,
-                };
-            throw error;
-        }
-    });
-    const committed = (await square.artifact.transact((facts) => {
-        // Selected-row decoding is storage work, not evidence that admission safely refused.
-        const proposed = decideAct(facts, { 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 }) });
-        const holder = proposed.type === 'held' ? facts.hold().actor : undefined;
-        const decision = rejectUnsentActivity(() => {
-            const decision = proposed;
-            if (decision.type === 'blocked')
-                throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending: decision.activitySummaries.reduce((count, summary) => count + summary.count, 0) });
-            if (decision.type === 'held') {
-                throw new SquareError('held', 'The square is held', { ...(holder === undefined ? {} : { holder }), ...(decision.reason === undefined ? {} : { holdReason: decision.reason }) });
-            }
-            if (decision.type === 'capped')
-                throw new SquareError('capped', `${participantIdentity(name)} reached the activity cap`);
-            if (decision.type === 'throttled')
-                throw new SquareError('throttled', `${name} is throttled`, { retryAfterMs: decision.delayMs });
-            if (decision.type === 'bell_quota')
-                throw new SquareError('bell_quota', `${participantIdentity(name)} cannot ring the bell yet`, { retryAfterMs: Math.max(1, decision.nextAt - now) });
-            return decision;
-        });
-        const stored = facts.land(decision.act);
-        return {
-            stored,
-            observation: {
-                standingCount: inSquareCount(facts), held: facts.hold().active, now,
-                ownActivityCount: facts.participant(name).sayCount, hardCap: facts.header().hardCap,
-            },
-            ...(decision.unmatchedMentions === undefined ? {} : { unmatchedMentions: decision.unmatchedMentions }),
-            ...(decision.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: decision.replyAuthorNotHere }),
-        };
-    }, control?.signal)).value;
-    await publishCommittedIdentity(square, name);
-    const delivery = square.wakeTransport !== undefined && square.hostLedger !== undefined && square.location !== undefined && square.location !== 'memory'
-        ? await deliverPending({ artifact: square.artifact, hostLedger: square.hostLedger, transport: square.wakeTransport, location: square.location, activity: committed.stored.index, now })
-            .catch(() => ({ attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 }))
-        : { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 };
-    const { stored, observation, ...metadata } = committed;
-    return { activity: toPublicActivity(stored), delivery, observation, ...metadata };
-}
-async function landListenerChange(square, verb, actor, target, control) {
-    throwIfAborted(control);
-    const now = square.clock();
-    const committed = (await square.artifact.transact((facts) => {
-        const act = verb === 'listen' ? coreListen(facts, actor, target, now) : verb === 'ignore' ? coreIgnore(facts, actor, target, now) : coreUnlisten(facts, actor, target, now);
-        const stored = act === undefined ? null : facts.land(act);
-        return { stored, observation: { standingCount: inSquareCount(facts), held: facts.hold().active, now } };
-    }, control?.signal)).value;
-    return { activity: committed.stored === null ? null : toPublicActivity(committed.stored), observation: committed.observation };
-}
-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); }
-export function unlisten(square, actor, target, control) { return landListenerChange(square, 'unlisten', actor, target, control); }
-export async function listening(square, actor, control) { return (await square.artifact.read((facts) => coreListening(facts, actor), control?.signal)).value; }
-async function landCore(square, verb, actor, body = '', fence = {}, control) {
-    if (verb === 'done')
-        validateDoneBody(body);
-    const hostLedger = verb === 'done' ? square.hostLedger : undefined;
-    const session = hostLedger === undefined ? undefined : processIdentity(square.env ?? process.env).session;
-    const commitAndCleanup = async () => {
-        // Owner admission, commit and route/presence cleanup share the host claim critical section.
-        if (verb === 'done' && !await assertLiveOwner(square, actor, fence.expectedEpoch))
-            throw new SquareError('already_done', `${participantIdentity(actor)} already stands here — another session holds the name`);
-        const owners = hostLedger === undefined ? [] : (await hostLedger.listPresence({ location: square.location, participant: actor })).filter((row) => row.session === session);
-        const now = square.clock();
-        const stored = (await square.artifact.transact((facts) => {
-            const result = facts.land(verb === 'done' ? coreDone(facts, actor, body, now) : verb === 'hold' ? coreHold(facts, actor, body, now) : coreResume(facts, actor, now));
-            if (session !== undefined)
-                dropEndedSessionWakeRoutes(facts, square.location, session, { expectedEpoch: fence.expectedEpoch, force: true, participant: actor });
-            return { activity: toPublicActivity(result), observation: {
-                    activity: result, standingCount: inSquareCount(facts), held: facts.hold().active, now,
-                } };
-        }, control?.signal)).value;
-        for (const row of owners)
-            await hostLedger.removePresenceIfUnchanged(row).catch((error) => {
-                process.stderr.write(`! host presence cleanup degraded: ${error instanceof Error ? error.message : String(error)}\n`);
-            });
-        return stored;
-    };
-    return hostLedger === undefined ? commitAndCleanup() : hostLedger.withClaimLock(commitAndCleanup, control?.signal);
-}
-export function done(square, name, body = '', fence = {}, control) { return landCore(square, 'done', name, body, fence, control); }
-function liveClaimedParticipants(rows, sessionId) {
-    const claimed = new Set(), foreign = new Set();
-    for (const row of rows)
-        (row.session === sessionId ? claimed : foreign).add(nameKey(row.participant));
-    for (const key of foreign)
-        claimed.delete(key);
-    return claimed;
-}
-async function readLiveClaimedParticipants(hostLedger, location, sessionId, now) {
-    try {
-        return liveClaimedParticipants(await hostLedger.listPresence({ location, now }), sessionId);
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function endOwnedSession(square, name, sessionId, expectedEpoch) {
-    const { location, hostLedger } = square;
-    const run = async () => {
-        const now = square.clock();
-        let currentSessionId, ownerMatches = expectedEpoch === undefined;
-        let ownerRecords = [];
-        let liveParticipants = new Set();
-        if (location !== undefined && location !== 'memory' && hostLedger !== undefined) {
-            try {
-                const rows = await hostLedger.listPresence({ location, now });
-                const bindings = rows.filter((row) => nameKey(row.participant) === nameKey(name));
-                currentSessionId = bindings.find((row) => row.session !== sessionId)?.session ?? bindings.toSorted((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0]?.session;
-                ownerRecords = bindings.filter((row) => row.session === sessionId);
-                liveParticipants = liveClaimedParticipants(rows, sessionId);
-                if (expectedEpoch !== undefined) {
-                    const owner = await readParticipantOwner(location, name, hostLedger);
-                    ownerMatches = owner !== undefined && owner.session === sessionId && presenceEpoch(owner) === expectedEpoch;
-                }
-            }
-            catch {
-                liveParticipants = undefined;
-            }
-        }
-        const stored = (await square.artifact.transact((facts) => {
-            let committed = null;
-            if (location !== undefined && location !== 'memory' && ownerMatches && sessionCanEndParticipant(facts, location, name, sessionId, currentSessionId)) {
-                try {
-                    committed = facts.land(coreDone(facts, name, '', now));
-                }
-                catch (error) {
-                    if (!isSquareError(error) || (error.code !== 'already_done' && error.code !== 'not_joined'))
-                        throw error;
-                }
-            }
-            if (location !== undefined && location !== 'memory')
-                dropEndedSessionWakeRoutes(facts, location, sessionId, { expectedEpoch, liveParticipants, force: committed !== null, participant: name });
-            return committed;
-        })).value;
-        if (stored !== null)
-            for (const row of ownerRecords)
-                await hostLedger.removePresenceIfUnchanged(row).catch((error) => {
-                    process.stderr.write(`! host presence cleanup degraded: ${error instanceof Error ? error.message : String(error)}\n`);
-                });
-        return stored;
-    };
-    const stored = hostLedger === undefined ? await run() : await hostLedger.withClaimLock(run);
-    return stored === null ? null : { activity: toPublicActivity(stored) };
-}
-export async function retireEndedSessionRoutes(square, sessionId) {
-    const { location, hostLedger } = square;
-    if (location === undefined || hostLedger === undefined)
-        return;
-    await hostLedger.withClaimLock(async () => {
-        const liveParticipants = await readLiveClaimedParticipants(hostLedger, location, sessionId, square.clock());
-        await square.artifact.transact((facts) => { dropEndedSessionWakeRoutes(facts, location, sessionId, { liveParticipants, force: false }); });
-    });
-}
-export function hold(square, name, reason = '', control) { return landCore(square, 'hold', name, reason, {}, control); }
-export function resume(square, name, control) { return landCore(square, 'resume', name, '', {}, control); }

package/dist/square-projections.d.ts

@@ -1,31 +0,0 @@
-import { type InboxMembership } from './model.js';
-import type { HostLedgerPort, PresentationEvidenceProjection, SessionBindingProjection } from './ports.js';
-/** A fresh blocking catch owns only the notifications admitted by its filter. */
-export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
-/**
- * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
- * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
- * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
- * ledger errors stay exactly as the boundary callers read them.
- */
-export declare function projectBoundaryEligibility(input: {
-    readonly hostLedger: HostLedgerPort;
-    readonly sessionId: string;
-    readonly inbox: readonly InboxMembership[];
-}): Promise<InboxMembership[]>;
-export declare function projectSessionBindings(input: {
-    readonly hostLedger: HostLedgerPort;
-    readonly sessionId?: string;
-    readonly location?: string;
-    readonly now?: number;
-}): Promise<readonly SessionBindingProjection[]>;
-export declare function projectPresentationEvidence(input: {
-    readonly hostLedger: HostLedgerPort;
-    readonly location?: string;
-    readonly participant?: string;
-    readonly sessionId?: string;
-    readonly activity?: string;
-    readonly now?: number;
-}): Promise<readonly PresentationEvidenceProjection[]>;
-/** Successful boundary output, including a clipped preview, suppresses awareness wake. */
-export declare function presentationSuppressesWake(evidence: readonly Pick<PresentationEvidenceProjection, 'outcome'>[]): boolean;

package/dist/square-projections.js

@@ -1,64 +0,0 @@
-import { formatActivityId } from './square-core.js';
-import { nameKey } from './model.js';
-import { leaseOwnsNotification } from './delivery.js';
-import { canonicalPath } from './canonical-path.js';
-/** A fresh blocking catch owns only the notifications admitted by its filter. */
-export function pendingAtBoundary(inbox) {
-    return inbox.map((membership) => {
-        const lease = membership.catchLease;
-        if (lease === undefined)
-            return membership;
-        return { ...membership, notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })) };
-    }).filter((membership) => membership.notifications.length > 0);
-}
-/**
- * One eligibility projection for a freshly read session inbox: a fresh catch lease owns what it
- * admitted, and a delivered (or clipped) boundary already raised awareness for its activity, so
- * neither belongs at the next boundary. Ordering, session scoping, suppression outcomes and
- * ledger errors stay exactly as the boundary callers read them.
- */
-export async function projectBoundaryEligibility(input) {
-    const memberships = pendingAtBoundary([...input.inbox]);
-    if (memberships.length === 0)
-        return [];
-    const evidence = await projectPresentationEvidence({ hostLedger: input.hostLedger, sessionId: input.sessionId });
-    const presented = new Map();
-    for (const row of evidence) {
-        if (row.outcome !== 'presented' && row.outcome !== 'clipped')
-            continue;
-        const key = JSON.stringify([row.location, nameKey(row.participant)]);
-        let activities = presented.get(key);
-        if (activities === undefined)
-            presented.set(key, activities = new Set());
-        activities.add(row.activity);
-    }
-    const pending = [];
-    for (const membership of memberships) {
-        const key = JSON.stringify([await canonicalPath(membership.squarePath), nameKey(membership.name)]);
-        const activities = presented.get(key);
-        const notifications = membership.notifications.filter((notification) => !activities?.has(formatActivityId(notification.actIndex)));
-        if (notifications.length > 0)
-            pending.push({ ...membership, notifications });
-    }
-    return pending;
-}
-export async function projectSessionBindings(input) {
-    const rows = await input.hostLedger.listPresence({ location: input.location, session: input.sessionId, now: input.now });
-    return rows.map((record) => ({
-        location: record.location,
-        participant: record.participant,
-        sessionId: record.session,
-        channel: record.channel,
-        ...(record.epoch === undefined ? {} : { epoch: record.epoch }),
-        ...(record.cancelledThrough === undefined ? {} : { cancelledThrough: record.cancelledThrough }),
-        updatedAt: record.updatedAt ?? 0,
-    }));
-}
-export async function projectPresentationEvidence(input) {
-    const rows = await input.hostLedger.listEvidence({ kind: 'presentation', location: input.location, participant: input.participant, session: input.sessionId, activity: input.activity, now: input.now });
-    return rows.map((row) => ({ location: row.location, participant: row.participant, sessionId: row.session, activity: row.activity, outcome: row.outcome, ...(row.at === undefined ? {} : { at: row.at }) }));
-}
-/** Successful boundary output, including a clipped preview, suppresses awareness wake. */
-export function presentationSuppressesWake(evidence) {
-    return evidence.some((row) => row.outcome === 'clipped' || row.outcome === 'presented');
-}

package/dist/wake-attempts.d.ts

@@ -1,10 +0,0 @@
-import type { WakeAttention } from './host-ledger.js';
-import { type WakeReleaseDiagnostic } from './wake-evidence.js';
-export declare function redactWakeDiagnostic(value: unknown, env?: NodeJS.ProcessEnv): unknown;
-export declare function readWakeReleaseDiagnostics(opts?: {
-    location?: string;
-    attention?: WakeAttention;
-    sessionId?: string;
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<WakeReleaseDiagnostic[]>;