@astrosheep/square 0.3.63 → 0.3.65

package/dist/registry.js

@@ -1,97 +1,47 @@
-/** Machine-local participant discovery cache. */
-import path from 'node:path';
-import { withFileLock } from './file-lock.js';
-import { sameName, SquareError } from './model.js';
-import { isCurrentlyJoined } from './runtime.js';
-import { squareAssignedParticipantName as computeSquareAssignedParticipantName } from './participant-identity.js';
+/** Participant ownership and local session identity on the host ledger. */
+import { SquareError } from './model.js';
+import { harnessSessionSources, squareAssignedParticipantName as computeSquareAssignedParticipantName } from './participant-identity.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { hostLedgerRoot } from './host-ledger-root.js';
-const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const PRESENCE_CLAIM_LOCK = { retryMs: 10 };
-const LOCAL_SESSION_SOURCES = [
-    { variable: 'CLAUDE_CODE_SESSION_ID', channel: 'claude-code', child: 'CLAUDE_CODE_CHILD_SESSION' },
-    { variable: 'CODEX_THREAD_ID', channel: 'codex' },
-    { variable: 'OPENCODE_SESSION_ID', channel: 'opencode' },
-    { variable: 'PI_SESSION_ID', channel: 'pi' },
-];
-export function registryPath(env = process.env) { return env.SQUARE_REGISTRY || path.join(hostLedgerRoot(env), '..', 'sessions.ndjsonl'); }
-export async function canonicalSquarePath(squarePath) { const absolute = path.resolve(squarePath); try {
-    return await (await import('node:fs/promises')).realpath(absolute);
-}
-catch {
-    return absolute;
-} }
-function ledgerRoot(env) { return hostLedgerRoot(env); }
-function ledger(env) { return createHostLedgerPort({ rootPath: ledgerRoot(env) }); }
+import { canonicalPath } from './canonical-path.js';
 export function presenceEpoch(record) {
     return typeof record?.epoch === 'number' && Number.isSafeInteger(record.epoch) && record.epoch > 0 ? record.epoch : 0;
 }
-function toBinding(record) {
-    return {
-        sessionId: record.session,
-        name: record.participant,
-        squarePath: record.location,
-        channel: record.channel,
-        child: false,
-        ...(record.route === undefined ? {} : { route: record.route }),
-        updatedAt: record.updatedAt ?? 0,
-        epoch: presenceEpoch(record),
-    };
-}
-function presenceClaimLockPath(env) {
-    return path.join(ledgerRoot(env), 'presence-claim.lock');
-}
-/** Runs `fn` inside the ownership claim critical section, under the same lock as claims and finalize. */
-export async function withOwnershipClaimLock(env, fn, signal) {
-    return withFileLock(presenceClaimLockPath(env), { ...PRESENCE_CLAIM_LOCK, signal }, fn);
-}
-async function activeBindings(now, env) { return (await ledger(env).listPresence({ now })).map(toBinding).sort((a, b) => b.updatedAt - a.updatedAt); }
-async function writePresence(sessionId, name, squarePath, options, done) { if (!sessionId || !name || !squarePath)
-    return; const env = options.env ?? process.env; const channel = options.channel ?? 'unknown'; const port = ledger(env); const location = await canonicalSquarePath(squarePath); if (done)
-    await port.removePresence({ location, participant: name, session: sessionId, channel });
-else
-    await port.ensurePresence({ location, participant: name, session: sessionId, channel, updatedAt: options.at ?? Date.now() }); }
-export function recordJoin(sessionId, name, squarePath, options = {}) { return writePresence(sessionId, name, squarePath, options, false); }
-export async function recordDone(sessionId, name, squarePath, options = {}) {
-    await writePresence(sessionId, name, squarePath, options, true);
+/** The current owner: the highest epoch wins, then the most recently updated row. */
+function currentOwner(rows) {
+    return [...rows].sort((left, right) => presenceEpoch(right) - presenceEpoch(left) || (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
 }
-export async function readActiveBindings(now = Date.now(), env = process.env) { try {
-    return await activeBindings(now, env);
-}
-catch {
-    return [];
-} }
-export async function lookupSessionBindings(sessionId, now = Date.now(), env = process.env) { return (await readActiveBindings(now, env)).filter((binding) => binding.sessionId === sessionId); }
-export async function lookupSession(sessionId, now = Date.now(), env = process.env) { return (await lookupSessionBindings(sessionId, now, env)).map(({ name, squarePath }) => ({ name, squarePath })); }
-export async function lookupParticipant(squarePath, name, now = Date.now(), env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); return (await readActiveBindings(now, env)).filter((binding) => binding.squarePath === canonicalPath && sameName(binding.name, name)); }
-export async function localParticipantOwner(squarePath, name, env = process.env, now = Date.now()) { const sessionIds = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); if (sessionIds.size === 0)
-    return undefined; return (await lookupParticipant(squarePath, name, now, env)).find((binding) => sessionIds.has(binding.sessionId))?.sessionId; }
-export async function localParticipantName(squarePath, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await lookupSession(identity.sessionId, Date.now(), env)).filter((item) => item.squarePath === canonicalPath).map((item) => item.name)))).flat()); return names.size === 1 ? [...names][0] : undefined; }
+export async function localParticipantName(squarePath, hostLedger, env = process.env) { const canonical = await canonicalPath(squarePath); const names = new Set((await Promise.all(localSessionIdentities(env).map(async (identity) => (await hostLedger.listPresence({ location: canonical, session: identity.sessionId })).map((row) => row.participant)))).flat()); return names.size === 1 ? [...names][0] : undefined; }
 export function squareAssignedParticipantName(env = process.env) { return computeSquareAssignedParticipantName(env); }
-export async function readParticipantOwner(squarePath, name, env = process.env) {
-    const bindings = await lookupParticipant(squarePath, name, Date.now(), env);
-    return bindings.sort((left, right) => right.epoch - left.epoch || right.updatedAt - left.updatedAt)[0];
+export async function readParticipantOwner(squarePath, name, hostLedger) {
+    // The registry cache this read replaces reported an unreadable cache as "no visible owner";
+    // an ownership read stays equally tolerant so a degraded ledger cannot fail an operation.
+    const rows = await participantPresence(squarePath, name, hostLedger).catch(() => []);
+    return currentOwner(rows);
+}
+async function participantPresence(squarePath, name, hostLedger) {
+    const canonical = await canonicalPath(squarePath);
+    return hostLedger.listPresence({ location: canonical, participant: name, now: Date.now() });
 }
-export async function sessionOwnsParticipant(squarePath, name, sessionId, env = process.env, expectedEpoch) {
-    const owner = await readParticipantOwner(squarePath, name, env);
-    if (owner === undefined || owner.sessionId !== sessionId)
+export async function sessionOwnsParticipant(squarePath, name, sessionId, hostLedger, expectedEpoch) {
+    const owner = await readParticipantOwner(squarePath, name, hostLedger);
+    if (owner === undefined || owner.session !== sessionId)
         return false;
-    return expectedEpoch === undefined || owner.epoch === expectedEpoch;
+    return expectedEpoch === undefined || presenceEpoch(owner) === expectedEpoch;
 }
-export async function releaseSessionParticipantClaim(squarePath, name, env, claim) {
+export async function releaseSessionParticipantClaim(hostLedger, claim) {
     if (claim?.status !== 'acquired')
         return;
-    const port = ledger(env);
-    await port.removePresenceIfUnchanged(claim.record);
+    await hostLedger.removePresenceIfUnchanged(claim.record);
 }
-export async function claimSessionParticipant(squarePath, name, env = process.env, signal) {
+export async function claimSessionParticipant(squarePath, name, hostLedger, env = process.env, signal) {
     const identity = localSessionIdentities(env)[0];
     if (identity === undefined)
         return undefined;
     if (signal?.aborted)
         throw signal.reason ?? new Error('Operation aborted');
-    const location = await canonicalSquarePath(squarePath);
-    const result = await ledger(env).claimPresence({
+    const location = await canonicalPath(squarePath);
+    const result = await hostLedger.claimPresence({
         location,
         participant: name,
         session: identity.sessionId,
@@ -108,28 +58,25 @@ export async function claimSessionParticipant(squarePath, name, env = process.en
 }
 /**
  * Fenced takeover: the ownership claim and the lifecycle run as one critical section under the
- * presence-claim lock, so no second takeover can interleave between claim and commit. The claim
+ * claim lock, so no second takeover can interleave between claim and commit. The claim
  * persists nothing until the lifecycle commits: standing owner rows stay authoritative through
  * the lifecycle (a self-takeover can therefore never clobber its own standing row). On success
  * the standing rows are replaced by the new owner's row at the claim epoch; on refusal, rows
  * carrying the claim token (session + channel + claim epoch) are withdrawn and the captured
  * standing rows are restored exactly.
  */
-export async function claimSessionTakeover(squarePath, name, env = process.env, opts = {}, lifecycle, signal) {
+export async function claimSessionTakeover(squarePath, name, hostLedger, env = process.env, opts = {}, lifecycle, signal) {
     const identity = localSessionIdentities(env)[0];
     if (identity === undefined)
         throw new SquareError('invalid_args', 'No local session identity for takeover');
-    const location = await canonicalSquarePath(squarePath);
-    return withFileLock(presenceClaimLockPath(env), { ...PRESENCE_CLAIM_LOCK, signal }, async () => {
-        const port = ledger(env);
-        const standing = await port.listPresence({ location, participant: name });
-        const owner = standing
-            .map((row) => toBinding(row))
-            .sort((left, right) => right.epoch - left.epoch || right.updatedAt - left.updatedAt)[0];
-        const currentEpoch = owner?.epoch ?? 0;
+    const location = await canonicalPath(squarePath);
+    return hostLedger.withClaimLock(async () => {
+        const standing = await hostLedger.listPresence({ location, participant: name });
+        const owner = currentOwner(standing);
+        const currentEpoch = presenceEpoch(owner);
         const epochMatches = opts.expectedEpoch === undefined || currentEpoch === opts.expectedEpoch;
         const sessionMatches = opts.expectedSession === undefined
-            || (opts.expectedSession === '' ? owner === undefined : owner?.sessionId === opts.expectedSession);
+            || (opts.expectedSession === '' ? owner === undefined : owner?.session === opts.expectedSession);
         if (!epochMatches || !sessionMatches) {
             return { status: 'busy', epoch: currentEpoch };
         }
@@ -143,59 +90,34 @@ export async function claimSessionTakeover(squarePath, name, env = process.env,
             // token (session + channel + epoch) — whatever the lifecycle itself ensured — then restore
             // the captured standing rows so the old owner survives byte-consistently. Foreign rows and
             // later owners are never touched.
-            const tokenRows = await ledger(env).listPresence({ location, participant: name, session: identity.sessionId });
+            const tokenRows = await hostLedger.listPresence({ location, participant: name, session: identity.sessionId });
             for (const row of tokenRows) {
                 if (row.channel === identity.channel && presenceEpoch(row) === epoch)
-                    await ledger(env).removePresence({ location: row.location, participant: row.participant, session: row.session, channel: row.channel });
+                    await hostLedger.removePresence({ location: row.location, participant: row.participant, session: row.session, channel: row.channel });
             }
             for (const row of standing)
-                await ledger(env).ensurePresence(row);
+                await hostLedger.ensurePresence(row);
             throw error;
         }
         // Finalize: the lifecycle committed. Replace the standing owner with the new owner's row at
         // the claim epoch where the owner was visible, so exactly one current owner
         // remains — also when the takeover is a self-takeover (same session as the standing owner).
         for (const row of standing)
-            await ledger(env).removePresence({ location: row.location, participant: row.participant, session: row.session, channel: row.channel });
-        await ledger(env).ensurePresence({ location, participant: name, session: identity.sessionId, channel: identity.channel, updatedAt: Date.now(), epoch });
+            await hostLedger.removePresence({ location: row.location, participant: row.participant, session: row.session, channel: row.channel });
+        await hostLedger.ensurePresence({ location, participant: name, session: identity.sessionId, channel: identity.channel, updatedAt: Date.now(), epoch });
         return { status: 'acquired', sessionId: identity.sessionId, epoch, result };
-    });
+    }, signal);
 }
-export async function releaseSessionParticipant(squarePath, name, env = process.env) {
+export async function releaseSessionParticipant(squarePath, name, hostLedger, env = process.env) {
     const identity = localSessionIdentities(env)[0];
     if (identity === undefined)
         return;
-    await ledger(env).removePresence({ location: squarePath, participant: name, session: identity.sessionId, channel: identity.channel });
+    await hostLedger.removePresence({ location: squarePath, participant: name, session: identity.sessionId, channel: identity.channel });
 }
-export async function bindCurrentParticipant(squarePath, name, env = process.env) { if (squareAssignedParticipantName(env) !== name)
-    throw new SquareError('invalid_args', `The current session is not assigned ${name}`); const sessionId = await localParticipantOwner(squarePath, name, env); if (sessionId !== undefined)
-    return { created: false, sessionId }; if ((await lookupParticipant(squarePath, name, Date.now(), env)).at(0) !== undefined)
-    throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`); await recordLocalJoin(name, squarePath, env); const currentSessionId = await localParticipantOwner(squarePath, name, env); if (currentSessionId === undefined)
-    throw new Error(`Current participant binding did not commit for ${name}`); return { created: true, sessionId: currentSessionId }; }
-export async function unbindCurrentParticipant(squarePath, name, env = process.env) { const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); const current = (await lookupParticipant(squarePath, name, Date.now(), env)).filter((binding) => identities.has(binding.sessionId)); for (const binding of current)
-    await recordSessionDone(binding.sessionId, binding.name, binding.squarePath, binding.channel, env); return current.length > 0; }
-function bindingIsProvablyObsolete(binding, acts) { return acts !== undefined && !isCurrentlyJoined(acts, binding.name); }
-export async function pruneRegistry(readActs, now = Date.now()) { const active = await readActiveBindings(now); let removed = 0; for (const binding of active) {
-    if (!bindingIsProvablyObsolete(binding, await readActs(binding.squarePath)))
-        continue;
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at: now });
-    removed++;
-} return { removed, kept: active.length - removed }; }
 function addLocalSession(identities, sessionId, channel, child, paseoAgentId) { if (!sessionId || identities.some((identity) => identity.sessionId === sessionId))
     return; identities.push({ sessionId, channel, child, ...(paseoAgentId ? { paseoAgentId } : {}) }); }
-export function localSessionIdentities(env = process.env) { const paseoAgentId = env.PASEO_AGENT_ID?.trim() || undefined; const identities = []; for (const source of LOCAL_SESSION_SOURCES)
-    addLocalSession(identities, env[source.variable]?.trim(), source.channel, source.child !== undefined && env[source.child] === '1', paseoAgentId); addLocalSession(identities, paseoAgentId, 'paseo', false, paseoAgentId); return identities; }
+export function localSessionIdentities(env = process.env) { const paseoAgentId = env.PASEO_AGENT_ID?.trim() || undefined; const identities = []; for (const source of harnessSessionSources)
+    addLocalSession(identities, env[source.variable]?.trim(), source.channel, source.childVariable !== undefined && env[source.childVariable] === '1', paseoAgentId); return identities; }
 export function hasAutomaticDeliveryIdentity(env = process.env) { return localSessionIdentities(env).length > 0; }
-export async function recordLocalJoin(name, squarePath, env = process.env) { const at = Date.now(); const identities = localSessionIdentities(env); const current = await lookupParticipant(squarePath, name, at, env); for (const identity of identities) {
-    for (const binding of current.filter((item) => item.sessionId === identity.sessionId))
-        await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env });
-    await recordJoin(identity.sessionId, name, squarePath, { ...identity, at, env });
-} }
-export async function recordLocalDone(name, squarePath, env = process.env) { const at = Date.now(); const identities = new Set(localSessionIdentities(env).map((identity) => identity.sessionId)); const current = (await lookupParticipant(squarePath, name, at, env)).filter((binding) => identities.has(binding.sessionId)); for (const binding of current)
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env }); }
-export async function recordSessionJoin(sessionId, name, squarePath, channel, env = process.env) { const at = Date.now(); const current = (await lookupParticipant(squarePath, name, at, env)).filter((binding) => binding.sessionId === sessionId); for (const binding of current)
-    await recordDone(binding.sessionId, binding.name, binding.squarePath, { channel: binding.channel, at, env }); await recordJoin(sessionId, name, squarePath, { channel, at, env }); return sessionId; }
-export async function recordSessionDone(sessionId, name, squarePath, channel, env = process.env) { const canonicalPath = await canonicalSquarePath(squarePath); const binding = (await lookupSessionBindings(sessionId, Date.now(), env)).find((item) => item.squarePath === canonicalPath && sameName(item.name, name) && item.channel === channel); if (binding === undefined)
-    return false; const options = { channel, at: Date.now(), env }; await recordDone(sessionId, binding.name, binding.squarePath, options); return true; }
 /** Bind the host ledger to the caller's captured environment. */
-export function hostLedgerForEnv(env = process.env) { return ledger(env); }
+export function hostLedgerForEnv(env = process.env) { return createHostLedgerPort({ rootPath: hostLedgerRoot(env) }); }

package/dist/routes.d.ts

@@ -13,25 +13,8 @@ export interface WakeRouteCapabilities {
     readonly canUse: (kind: WakeRouteKind, address: Readonly<Record<string, string>>) => boolean;
 }
 export declare function defaultWakeRouteCapabilities(hostLedger?: import('./host-ledger.js').HostLedgerPort): Promise<WakeRouteCapabilities>;
-export declare function selectPrimaryWakeRoute(input: {
-    readonly boundary: WakeBoundary;
-    readonly env: NodeJS.ProcessEnv;
-    readonly capabilities: WakeRouteCapabilities;
-}): Omit<WakeRoute, 'updatedAt'> | undefined;
-export declare function routeIdentityKey(route: Pick<WakeRoute, 'location' | 'participant' | 'sessionId'>, location?: string): string;
 export declare function resolvePrimaryWakeRoute(boundary: WakeBoundary, env: NodeJS.ProcessEnv, capabilities: WakeRouteCapabilities): Omit<WakeRoute, 'updatedAt'> | undefined;
-export declare function readWakeRoutes(opts?: {
-    location?: string;
-    participant?: string;
-    sessionId?: string;
-    freshOnly?: boolean;
-    now?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<WakeRoute[]>;
-export declare function upsertWakeRoute(route: Omit<WakeRoute, 'updatedAt'>, opts?: {
-    at?: number;
-    env?: NodeJS.ProcessEnv;
-}): Promise<void>;
+export declare function routeIdentityKey(route: Pick<WakeRoute, 'location' | 'participant' | 'sessionId'>, location?: string): string;
 export type RouteEpoch = {
     readonly epoch?: number;
 };
@@ -53,21 +36,11 @@ export declare function dropEndedSessionWakeRoutesFromState(state: import('./mod
     readonly participant?: string;
 }): void;
 export declare function dropParticipantWakeRoutesFromState(state: import('./model.js').SquareState, location: string, participant: string): void;
-export declare function sessionOwnsParticipantRoutes(state: import('./model.js').SquareState, location: string, participant: string, sessionId: string): boolean;
 export declare function sessionCanEndParticipant(state: import('./model.js').SquareState, location: string, participant: string, sessionId: string, currentSessionId?: string): boolean;
 export declare function publishWakeRoute(artifact: import('./ports.js').SquareArtifactPort, route: Omit<WakeRoute, 'updatedAt'> & RouteEpoch, opts?: {
     at?: number;
     requireCurrentSession?: boolean;
 }): Promise<void>;
-export declare function retireWakeRoute(route: WakeRoute, opts?: {
-    at?: number;
-    env?: NodeJS.ProcessEnv;
-    expectedEpoch?: number;
-}): Promise<void>;
 export declare function retireWakeRouteFromArtifact(artifact: import('./ports.js').SquareArtifactPort, route: Pick<WakeRoute, 'location' | 'participant' | 'sessionId'>, opts?: {
     readonly expectedEpoch?: number;
 }): Promise<void>;
-export declare function retireWakeRoutesForSessionFromArtifact(artifact: import('./ports.js').SquareArtifactPort, route: Pick<WakeRoute, 'location' | 'sessionId'>, opts?: {
-    readonly expectedEpoch?: number;
-}): Promise<void>;
-export declare function canonicalRouteLocation(location: string): Promise<string>;

package/dist/routes.js

@@ -1,9 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { nameKey } from './model.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
 import { isCurrentlyJoined } from './runtime.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) {
@@ -29,90 +26,35 @@ export async function defaultWakeRouteCapabilities(hostLedger) {
     catch { /* optional */ }
     return { canUse: (kind, address) => userCapable && available.has(kind) && Object.values(address).every((value) => value.trim() !== '') };
 }
-function nativeCandidate(boundary) {
-    if (boundary.provider === 'codex')
-        return { kind: 'codex-queue', address: { threadId: boundary.sessionId } };
-    if (boundary.provider === 'claude')
-        return { kind: 'claude-native', address: { sessionId: boundary.sessionId } };
-    if (boundary.provider === 'opencode')
-        return { kind: 'opencode-server', address: { sessionId: boundary.sessionId } };
-    if (boundary.provider === 'pi')
-        return { kind: 'pi-extension', address: { sessionId: boundary.sessionId } };
-    return undefined;
-}
-export function selectPrimaryWakeRoute(input) {
-    const { boundary, env, capabilities } = input;
+export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
     const paseoAgentId = env.PASEO_AGENT_ID?.trim();
     const candidates = [];
     if (paseoAgentId)
         candidates.push({ kind: 'paseo', address: { agentId: paseoAgentId } });
-    const native = nativeCandidate(boundary);
-    if (native)
-        candidates.push(native);
+    if (boundary.provider === 'codex')
+        candidates.push({ kind: 'codex-queue', address: { threadId: boundary.sessionId } });
     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]);
 }
-export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
-    return selectPrimaryWakeRoute({ boundary, env, capabilities });
-}
-async function withArtifact(location, fn) {
-    if (location === undefined)
-        return undefined;
-    try {
-        await fs.promises.access(location);
-        const square = await openSquare(location);
-        try {
-            return await fn(square);
-        }
-        finally {
-            await closeOpenSquare(square);
-        }
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function readWakeRoutes(opts = {}) {
-    const now = opts.now ?? Date.now();
-    const canonicalLocation = opts.location === undefined ? undefined : await canonicalRouteLocation(opts.location);
-    const routes = await withArtifact(canonicalLocation, async (square) => (await square.artifact.read()).state.routes ?? []) ?? [];
-    const filtered = routes.filter((route) => (opts.participant === undefined || nameKey(route.participant) === nameKey(opts.participant)) && (opts.sessionId === undefined || route.sessionId === opts.sessionId) && (!opts.freshOnly || now - route.updatedAt < ROUTE_FRESH_MS));
-    const canonicalized = await Promise.all(filtered.map(async (route) => ({ ...route, location: await canonicalRouteLocation(route.location), address: { ...route.address } })));
-    return canonicalLocation === undefined ? canonicalized : canonicalized.filter((route) => route.location === canonicalLocation);
-}
-export async function upsertWakeRoute(route, opts = {}) {
-    const location = await canonicalRouteLocation(route.location);
-    await withArtifact(location, async (square) => publishWakeRoute(square.artifact, { ...route, location }, opts));
-}
 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]);
 }
-function canonicalRouteLocationSync(location) {
-    const absolute = path.resolve(location);
-    // Match fs.promises.realpath used by artifact and presence adapters, including Windows 8.3 aliases.
-    try {
-        return fs.realpathSync.native(absolute);
-    }
-    catch {
-        return absolute;
-    }
-}
 export function applyWakeRouteToState(state, route, at = Date.now()) {
-    const location = canonicalRouteLocationSync(route.location);
+    const location = canonicalPathSync(route.location);
     state.routes = [...(state.routes ?? []).filter((item) => {
-            const itemLocation = canonicalRouteLocationSync(item.location);
+            const itemLocation = canonicalPathSync(item.location);
             return !(itemLocation === location && routeIdentityKey(item, itemLocation) === routeIdentityKey(route, location));
         }), { ...route, location, updatedAt: at }];
 }
 export function dropSessionWakeRoutesFromState(state, location, sessionId, expectedEpoch) {
-    const canonical = canonicalRouteLocationSync(location);
+    const canonical = canonicalPathSync(location);
     state.routes = (state.routes ?? []).filter((item) => {
-        if (item.sessionId !== sessionId || canonicalRouteLocationSync(item.location) !== canonical)
+        if (item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical)
             return true;
         if (expectedEpoch === undefined)
             return false;
@@ -129,9 +71,9 @@ export function dropSessionWakeRoutesFromState(state, location, sessionId, expec
  * published by a later generation.
  */
 export function dropEndedSessionWakeRoutesFromState(state, location, sessionId, opts) {
-    const canonical = canonicalRouteLocationSync(location);
+    const canonical = canonicalPathSync(location);
     state.routes = (state.routes ?? []).filter((item) => {
-        if (item.sessionId !== sessionId || canonicalRouteLocationSync(item.location) !== canonical)
+        if (item.sessionId !== sessionId || canonicalPathSync(item.location) !== canonical)
             return true;
         if (opts.participant !== undefined && nameKey(item.participant) !== nameKey(opts.participant))
             return true;
@@ -149,66 +91,42 @@ export function dropEndedSessionWakeRoutesFromState(state, location, sessionId,
     });
 }
 export function dropParticipantWakeRoutesFromState(state, location, participant) {
-    const canonical = canonicalRouteLocationSync(location);
-    state.routes = (state.routes ?? []).filter((item) => !(nameKey(item.participant) === nameKey(participant) && canonicalRouteLocationSync(item.location) === canonical));
-}
-export function sessionOwnsParticipantRoutes(state, location, participant, sessionId) {
-    const canonical = canonicalRouteLocationSync(location);
-    const owned = (state.routes ?? []).filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalRouteLocationSync(item.location) === canonical);
-    return owned.length > 0 && owned.every((item) => item.sessionId === sessionId);
+    const canonical = canonicalPathSync(location);
+    state.routes = (state.routes ?? []).filter((item) => !(nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical));
 }
 export function sessionCanEndParticipant(state, location, participant, sessionId, currentSessionId) {
-    const canonical = canonicalRouteLocationSync(location);
-    const owned = (state.routes ?? []).filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalRouteLocationSync(item.location) === canonical);
+    const canonical = canonicalPathSync(location);
+    const owned = (state.routes ?? []).filter((item) => nameKey(item.participant) === nameKey(participant) && canonicalPathSync(item.location) === canonical);
     if (owned.length === 0)
         return currentSessionId === sessionId;
     return owned.every((item) => item.sessionId === sessionId) && (currentSessionId === undefined || currentSessionId === sessionId);
 }
 export async function publishWakeRoute(artifact, route, opts = {}) {
-    const location = await canonicalRouteLocation(route.location);
+    const location = await canonicalPath(route.location);
     const at = opts.at ?? Date.now();
     await artifact.transact((state) => {
         if (opts.requireCurrentSession) {
-            const participantRoutes = (state.routes ?? []).filter((item) => nameKey(item.participant) === nameKey(route.participant) && canonicalRouteLocationSync(item.location) === location);
-            if (!isCurrentlyJoined(state.acts, route.participant) || participantRoutes.some((item) => item.sessionId !== route.sessionId))
+            if (!isCurrentlyJoined(state.acts, route.participant)
+                || (state.routes ?? []).some((item) => nameKey(item.participant) === nameKey(route.participant) && canonicalPathSync(item.location) === location && item.sessionId !== route.sessionId))
                 return { state, result: undefined };
         }
         const identity = routeIdentityKey({ ...route, location });
-        const matching = (state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalRouteLocationSync(item.location)) === identity);
+        const matching = (state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) === identity);
         const existing = matching[0];
         const existingEpoch = existing?.epoch;
         const epochMatches = route.epoch === undefined ? existingEpoch === undefined : existingEpoch === route.epoch;
         if (matching.length === 1 && existing !== undefined && existing.updatedAt > at - ROUTE_FRESH_MS && existing.kind === route.kind && existing.channel === route.channel && sameRouteAddress(existing.address, route.address) && epochMatches)
             return { result: undefined };
-        return { state: { ...state, routes: [...(state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalRouteLocationSync(item.location)) !== identity), { ...route, location, updatedAt: at }] }, result: undefined };
+        return { state: { ...state, routes: [...(state.routes ?? []).filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) !== identity), { ...route, location, updatedAt: at }] }, result: undefined };
     });
 }
-export async function retireWakeRoute(route, opts = {}) {
-    const location = await canonicalRouteLocation(route.location);
-    await withArtifact(location, async (square) => retireWakeRouteFromArtifact(square.artifact, { ...route, location }, opts));
-}
 export async function retireWakeRouteFromArtifact(artifact, route, opts = {}) {
-    const location = await canonicalRouteLocation(route.location);
+    const location = await canonicalPath(route.location);
     const target = routeIdentityKey({ ...route, location });
     await artifact.transact((state) => ({ state: { ...state, routes: (state.routes ?? []).filter((item) => {
-                const itemLocation = canonicalRouteLocationSync(item.location);
+                const itemLocation = canonicalPathSync(item.location);
                 if (routeIdentityKey(item, itemLocation) !== target)
                     return true;
-                const itemEpoch = item.epoch;
-                return opts.expectedEpoch !== undefined && itemEpoch !== opts.expectedEpoch;
-            }) }, result: undefined }));
-}
-export async function retireWakeRoutesForSessionFromArtifact(artifact, route, opts = {}) {
-    const location = canonicalRouteLocationSync(route.location);
-    await artifact.transact((state) => ({ state: { ...state, routes: (state.routes ?? []).filter((item) => {
-                if (canonicalRouteLocationSync(item.location) !== location || item.sessionId !== route.sessionId)
-                    return true;
-                if (opts.expectedEpoch === undefined)
-                    return false;
-                const itemEpoch = item.epoch;
-                return itemEpoch !== undefined && itemEpoch !== opts.expectedEpoch;
+                return opts.expectedEpoch !== undefined && item.epoch !== opts.expectedEpoch;
             }) }, result: undefined }));
 }
-export async function canonicalRouteLocation(location) {
-    return canonicalRouteLocationSync(location);
-}

package/dist/runtime.d.ts

@@ -1,10 +1,9 @@
 import { type ActivityId, type LandedAudienceReplay, type Reach } from './square-core.js';
-import { type StoredAct, type SquareState, type HoldState, type ActivityObservation, type ObservationState, type WatchLease } from './model.js';
+import { type StoredAct, type SquareState, type HoldState, type ObservationState, type WatchLease } from './model.js';
 export declare const WATCH_HEARTBEAT_MS: number;
 export declare const SLEEP_MS: number;
 export declare const STALE_MS: number;
 export declare const WATCH_STALE_MS: number;
-export declare const LOCK_RETRY_MS: number;
 export declare const THROTTLE_WINDOW_MS: number;
 export declare const UNREAD_BLOCK_GRACE_MS: number;
 /** 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. */
@@ -20,12 +19,10 @@ export declare function foldedState(squareState: SquareState): import("./square-
 export declare function rosterNames(squareState: SquareState): string[];
 export declare function inSquareCount(squareState: SquareState): number;
 export declare function resolveRosterName(squareState: SquareState, name: string): string | undefined;
-export declare function hasQuorum(squareState: SquareState, name: string, outs: Set<string>): boolean;
 export declare function countSays(acts: StoredAct[], name: string): number;
 export declare function sayNumberFor(acts: StoredAct[], target: StoredAct): number;
 /** Shared terminal condition for a participant's watch lifecycle. */
 export declare function watchTerminalStatus(squareState: SquareState, name: string): 'capped' | 'quorum' | undefined;
-export declare function doneNames(acts: StoredAct[]): Set<string>;
 export declare function joinedNames(acts: StoredAct[]): Set<string>;
 export declare function isCurrentlyJoined(acts: StoredAct[], name: string): boolean;
 /** Stable index of the recipient's most recent join act, if any. */
@@ -36,19 +33,16 @@ export declare function currentHold(acts: StoredAct[]): HoldState;
 export declare function publicActs(acts: StoredAct[]): Array<Extract<StoredAct, {
     kind: 'say' | 'done';
 }>>;
-export declare function observationFor(squareState: SquareState, name: string, index: number): ActivityObservation | undefined;
 export declare function recordObservation(squareState: SquareState, name: string, index: number, state: ObservationState, at?: number): boolean;
 export declare function readCursor(squareState: SquareState, name: string, landed?: LandedAudienceReplay): number;
-export declare function latestActIndex(acts: StoredAct[]): number;
 /**
+ * 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 declare function presenceEvidenceCursor(squareState: SquareState, name: string, landed?: LandedAudienceReplay): number;
-/** The last public act the participant was verifiably present for, or -1 when there is no evidence. */
 export declare function presenceAnchor(squareState: SquareState, name: string, landed?: LandedAudienceReplay): number;
 export declare function freshWatchLease(squareState: SquareState, name: string, at?: number): WatchLease | undefined;
-export declare function watchLease(squareState: SquareState, name: string): WatchLease | undefined;
 export declare function writeWatchLease(squareState: SquareState, name: string, lease: WatchLease): void;
 export declare function removeWatchLease(squareState: SquareState, name: string, leaseId: string): boolean;