@astrosheep/square 0.3.86 → 0.3.88

package/dist/ledger-maintenance.js

@@ -1,110 +0,0 @@
-import { createArtifactPort } from './artifact.js';
-import { canonicalPath } from './canonical-path.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { validateName } from './model.js';
-import { hostLedgerForEnv } from './registry.js';
-/**
- * Explicit host-ledger evidence maintenance.
- *
- * Old wake/presentation rows are retired only when a typed artifact snapshot proves the
- * recipient's attention is permanently closed: the activity reached them historically, and
- * either catch recorded a receipt or the recipient joined again past it. Everything else is
- * retained. Artifacts are read directly, one snapshot per canonical location, outside any
- * ledger lock; retirement is the ledger's exact-record compare-and-swap. No SQL lives here.
- */
-/** A row is old enough to consider once its landing time is at least this far behind now. */
-const RETIREMENT_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-/** The canonical activity coordinate the row names; leading zeros and other spellings are invalid. */
-function activityIndex(activity) {
-    const index = parseActivityId(activity);
-    return index === undefined || formatActivityId(index) !== activity ? undefined : index;
-}
-/** Old, durably closed-looking wake/presentation rows with usable coordinates. */
-function isCandidate(record, now) {
-    if (record.kind !== 'wake' && record.kind !== 'presentation')
-        return false;
-    if (record.outcome === 'dispatching')
-        return false;
-    if (typeof record.at !== 'number' || !Number.isFinite(record.at) || record.at > now - RETIREMENT_AGE_MS)
-        return false;
-    if (typeof record.location !== 'string' || record.location.length === 0)
-        return false;
-    try {
-        validateName(record.participant);
-    }
-    catch {
-        return false;
-    }
-    return true;
-}
-/**
- * One artifact snapshot for one location either proves each candidate closed or reports the
- * whole location unavailable. A missing, unreadable, or non-artifact path returns undefined
- * and its rows are retained.
- */
-async function provenClosable(location, group) {
-    const artifact = createArtifactPort(location);
-    try {
-        return (await artifact.read((facts) => group.filter((candidate) => {
-            const participant = candidate.record.participant;
-            if (facts.directedAt(participant, candidate.index) === undefined)
-                return false;
-            if (facts.receipt(participant, candidate.index) !== undefined)
-                return true;
-            const lastJoin = facts.participant(participant)?.lastJoinIndex;
-            return lastJoin !== undefined && lastJoin > candidate.index;
-        }))).value;
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        await artifact.close();
-    }
-}
-/** Maintenance entry: root selection uses the caller's captured environment. */
-export function gcHostLedger(options = {}) {
-    return maintainHostLedger(hostLedgerForEnv(options.env ?? process.env), options);
-}
-export async function maintainHostLedger(ledger, options = {}) {
-    const dryRun = options.dryRun === true;
-    const now = options.now ?? Date.now();
-    const records = await ledger.listEvidence({ includeReleased: true, includeExpired: true, now });
-    const groups = new Map();
-    for (const record of records) {
-        if (!isCandidate(record, now))
-            continue;
-        const index = activityIndex(record.activity);
-        if (index === undefined)
-            continue;
-        const location = await canonicalPath(record.location).catch(() => undefined);
-        if (location === undefined)
-            continue;
-        const group = groups.get(location);
-        if (group === undefined)
-            groups.set(location, [{ record, index }]);
-        else
-            group.push({ record, index });
-    }
-    let eligible = 0;
-    let retired = 0;
-    let casMisses = 0;
-    const unavailable = new Set();
-    for (const location of [...groups.keys()].sort()) {
-        const closable = await provenClosable(location, groups.get(location));
-        if (closable === undefined) {
-            unavailable.add(location);
-            continue;
-        }
-        eligible += closable.length;
-        if (dryRun)
-            continue;
-        for (const candidate of closable) {
-            if (await ledger.retireEvidenceIfUnchanged(candidate.record))
-                retired += 1;
-            else
-                casMisses += 1;
-        }
-    }
-    return { dryRun, eligible, retired, casMisses, unavailableArtifacts: [...unavailable].sort() };
-}

package/dist/open-square.d.ts

@@ -1,38 +0,0 @@
-import type { HostLedgerPort, SquareArtifactPort, SquareResourceOwner, WakeTransportPort } from './ports.js';
-import type { OperationControl } from './square-facade.js';
-/** Host-bound resource: artifact, captured environment, clock, ledger and transport. */
-export interface OpenSquare {
-    readonly artifact: SquareArtifactPort;
-    readonly clock: () => number;
-    readonly location: string;
-    readonly hostLedger?: HostLedgerPort;
-    readonly wakeTransport?: WakeTransportPort;
-    readonly env?: NodeJS.ProcessEnv;
-    /** False when a long-lived owner lent the connection; closing this view leaves it open. */
-    readonly ownsArtifact: boolean;
-    readonly automaticDelivery?: boolean;
-}
-export interface SquareBuildOptions {
-    markdown: string;
-    hardCap?: number | null;
-    throttlePerMinute?: number;
-    clock?: () => number;
-    hostLedger?: HostLedgerPort;
-    wakeTransport?: WakeTransportPort;
-    env?: NodeJS.ProcessEnv;
-    /** One caller deadline propagated into artifact busy retries. */
-    signal?: AbortSignal;
-}
-export interface SquareOpenOptions extends Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'> {
-    /** A caller-owned connection to reuse; this view never closes it. */
-    readonly artifact?: SquareArtifactPort;
-    readonly automaticDelivery?: boolean;
-}
-export declare function openSquare(squarePath: string, options?: SquareOpenOptions, control?: OperationControl): Promise<OpenSquare>;
-export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
-export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
-export declare function closeOpenSquare(square: OpenSquare): Promise<void>;
-/** Explicit-lifetime holder of one reused artifact connection. The first request
- * binds the location; a request for any other location is refused instead of
- * silently sharing the wrong square. The owner closes the connection once. */
-export declare function createSquareResourceOwner(): SquareResourceOwner;

package/dist/open-square.js

@@ -1,81 +0,0 @@
-import path from 'node:path';
-import { createArtifactPort, createSquare, prepareSquareBuild } from './artifact.js';
-import { InternalSquareError, SquareError } from './model.js';
-import { hostLedgerRoot } from './host-ledger-root.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-export async function openSquare(squarePath, options = {}, control) {
-    const env = { ...(options.env ?? process.env) };
-    const borrowed = options.artifact;
-    // A borrowed connection was opened by its owner without a request signal; this
-    // request may only abort its own read, never the shared connection's lifetime.
-    const artifact = borrowed ?? createArtifactPort(squarePath, undefined, options.signal);
-    try {
-        await artifact.read(facts => facts.header(), control?.signal);
-        return {
-            artifact, automaticDelivery: options.automaticDelivery, clock: options.clock ?? Date.now, location: squarePath, env, ownsArtifact: borrowed === undefined,
-            hostLedger: options.hostLedger ?? createHostLedgerPort({ rootPath: hostLedgerRoot(env) }),
-            wakeTransport: options.wakeTransport,
-        };
-    }
-    catch (error) {
-        if (borrowed === undefined)
-            await artifact.close();
-        if (error instanceof InternalSquareError && error.code === 'not_found')
-            throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
-        throw error;
-    }
-}
-export async function buildSquare(squarePath, options) {
-    try {
-        await createSquare(squarePath, { ...options, force: false }, options.markdown, options.signal);
-    }
-    catch (error) {
-        if (error instanceof InternalSquareError && error.code === 'conflict')
-            throw new SquareError('io', `Cannot build over an existing square at ${squarePath}`);
-        throw error;
-    }
-    return openSquare(squarePath, { ...options, signal: undefined });
-}
-export function buildMemorySquare(options) {
-    return {
-        artifact: createArtifactPort(':memory:', prepareSquareBuild(options, options.markdown)),
-        clock: options.clock ?? Date.now, location: 'memory',
-        hostLedger: options.hostLedger, wakeTransport: options.wakeTransport,
-        ownsArtifact: true,
-    };
-}
-export function closeOpenSquare(square) {
-    // A borrowed connection belongs to its owner; only owned views close it here.
-    return square.ownsArtifact === false ? Promise.resolve() : square.artifact.close();
-}
-/** Explicit-lifetime holder of one reused artifact connection. The first request
- * binds the location; a request for any other location is refused instead of
- * silently sharing the wrong square. The owner closes the connection once. */
-export function createSquareResourceOwner() {
-    let held;
-    let closed = false;
-    return {
-        artifact(location) {
-            if (closed)
-                throw new SquareError('unavailable', 'Square resource owner is closed');
-            const key = path.resolve(location);
-            if (held === undefined) {
-                // No external signal: a request must never become the shared connection's lifetime.
-                held = { location: key, artifact: createArtifactPort(key) };
-            }
-            if (held.location !== key) {
-                throw new SquareError('unavailable', `Square resource owner already holds ${held.location}; it cannot also open ${key}`);
-            }
-            return held.artifact;
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            const artifact = held?.artifact;
-            held = undefined;
-            if (artifact !== undefined)
-                await artifact.close();
-        },
-    };
-}

package/dist/participant-host.d.ts

@@ -1,23 +0,0 @@
-import type { HostLedgerPort, PresenceChannel, SquareArtifactPort } from './ports.js';
-import { type WakeRoute } from './routes.js';
-export interface HostContext {
-    readonly artifact: SquareArtifactPort;
-    readonly automaticDelivery?: boolean;
-    readonly clock: () => number;
-    readonly location?: string;
-    readonly hostLedger?: HostLedgerPort;
-    readonly env?: NodeJS.ProcessEnv;
-}
-export declare function processIdentity(env: NodeJS.ProcessEnv): {
-    session: string;
-    channel: PresenceChannel;
-};
-export declare function identityRouteDraft(context: HostContext, participant: string): Promise<Omit<WakeRoute, 'updatedAt'> | undefined>;
-/** One postcommit host observation; presence and route publication fail independently. */
-export declare function publishCommittedIdentity(context: HostContext, participant: string, epoch?: number): Promise<void>;
-export declare function retireIdentityRoute(context: HostContext, participant: string, expectedEpoch?: number): Promise<void>;
-export declare function assertLiveOwner(context: HostContext, participant: string, expectedEpoch?: number): Promise<boolean>;
-/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
-export declare function ensureLocalPresence(context: HostContext, participant: string, epoch?: number): Promise<{
-    readonly epoch?: number;
-} | undefined>;

package/dist/participant-host.js

@@ -1,92 +0,0 @@
-import { currentOwner, presenceEpoch, sessionOwnsParticipant } from './registry.js';
-import { firstHarnessSession } from './participant-identity.js';
-import { canonicalPath } from './canonical-path.js';
-import { defaultWakeRouteCapabilities, publishWakeRoute, retireWakeRouteFromArtifact, resolvePrimaryWakeRoute, ROUTE_FRESH_MS } from './routes.js';
-export function processIdentity(env) {
-    const found = firstHarnessSession(env);
-    return found === undefined ? { session: `process:${process.pid}`, channel: 'unknown' } : { session: found.sessionId, channel: found.channel };
-}
-export async function identityRouteDraft(context, participant) {
-    if (context.automaticDelivery === false || context.location === undefined || context.location === 'memory')
-        return undefined;
-    const identity = processIdentity(context.env ?? process.env);
-    if (identity.channel === 'unknown')
-        return undefined;
-    const provider = identity.channel === 'claude-code' ? 'claude' : identity.channel === 'opencode' ? 'opencode' : identity.channel === 'pi' ? 'pi' : identity.channel === 'paseo' ? 'paseo' : 'codex';
-    const boundary = { location: context.location, participant, sessionId: identity.session, provider };
-    const env = context.env ?? process.env;
-    // No adapter can add a route when the host has no candidate in the first place.
-    if (context.hostLedger === undefined || resolvePrimaryWakeRoute(boundary, env, { canUse: () => true }) === undefined)
-        return undefined;
-    return resolvePrimaryWakeRoute(boundary, env, await defaultWakeRouteCapabilities(context.hostLedger));
-}
-/** One postcommit host observation; presence and route publication fail independently. */
-export async function publishCommittedIdentity(context, participant, epoch) {
-    const observed = await ensureLocalPresence(context, participant, epoch).catch(() => undefined);
-    if (observed === undefined)
-        return;
-    try {
-        const route = await identityRouteDraft(context, participant);
-        if (route !== undefined)
-            await publishWakeRoute(context.artifact, { ...route, ...observed }, { at: context.clock(), requireCurrentSession: true });
-    }
-    catch { /* Optional route enrichment cannot undo the committed activity. */ }
-}
-export async function retireIdentityRoute(context, participant, expectedEpoch) {
-    if (context.location === undefined || context.location === 'memory')
-        return;
-    const identity = processIdentity(context.env ?? process.env);
-    await retireWakeRouteFromArtifact(context.artifact, { location: context.location, participant, sessionId: identity.session }, expectedEpoch === undefined ? {} : { expectedEpoch }).catch(() => undefined);
-}
-export async function assertLiveOwner(context, participant, expectedEpoch) {
-    const hostLedger = context.hostLedger;
-    if (hostLedger === undefined || context.location === undefined || context.location === 'memory')
-        return true;
-    const identity = processIdentity(context.env ?? process.env);
-    // Library callers without a harness session are not ownership-fenced unless an epoch was supplied.
-    if (identity.channel === 'unknown' && expectedEpoch === undefined)
-        return true;
-    return sessionOwnsParticipant(context.location, participant, identity.session, hostLedger, expectedEpoch);
-}
-/** Best-effort postcommit presence; a returned epoch also witnesses a readable host observation. */
-export async function ensureLocalPresence(context, participant, epoch) {
-    if (context.hostLedger === undefined || context.location === undefined || context.location === 'memory')
-        return;
-    const identity = processIdentity(context.env ?? process.env);
-    // Sessionless library operations do not establish host presence or ownership.
-    if (identity.channel === 'unknown')
-        return;
-    const now = Date.now();
-    let existing;
-    try {
-        existing = await context.hostLedger.listPresence({ location: await canonicalPath(context.location), participant, now });
-    }
-    catch (error) {
-        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
-        return;
-    }
-    const owner = currentOwner(existing);
-    const ownerEpoch = epoch ?? (owner === undefined ? undefined : presenceEpoch(owner));
-    const observed = ownerEpoch === undefined ? {} : { epoch: ownerEpoch };
-    // A fresh exact local binding at the observed (or explicit claim) generation already stands.
-    if (existing.some((row) => row.session === identity.session && row.channel === identity.channel
-        && now - (row.updatedAt ?? 0) < ROUTE_FRESH_MS
-        && (ownerEpoch === undefined || presenceEpoch(row) === ownerEpoch)))
-        return observed;
-    try {
-        const result = await context.hostLedger.ensurePresence({
-            location: context.location,
-            participant,
-            session: identity.session,
-            channel: identity.channel,
-            updatedAt: Date.now(),
-            ...(ownerEpoch === undefined || ownerEpoch <= 0 ? {} : { epoch: ownerEpoch }),
-        });
-        if (result.status === 'degraded')
-            throw result.error;
-    }
-    catch (error) {
-        process.stderr.write(`! host presence degraded: ${error instanceof Error ? error.message : String(error)}\n`);
-    }
-    return observed;
-}

package/dist/registry.d.ts

@@ -1,55 +0,0 @@
-/** Participant ownership and local session identity on the host ledger. */
-import { type FileHostLedgerPort } from './host-ledger-file-adapter.js';
-import type { HostLedgerPort, PresenceChannel, PresenceRecord } from './host-ledger.js';
-export declare function presenceEpoch(record: PresenceRecord | undefined): number;
-/** The current owner: the highest epoch wins, then the most recently updated row. */
-export declare function currentOwner(rows: readonly PresenceRecord[]): PresenceRecord | undefined;
-export declare function localParticipantName(squarePath: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
-export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
-export type OwnershipClaim = {
-    readonly status: 'acquired' | 'owned';
-    readonly record: PresenceRecord;
-    readonly sessionId: string;
-    readonly epoch: number;
-} | undefined;
-export type TakeoverClaimToken = {
-    readonly sessionId: string;
-    readonly epoch: number;
-};
-export type TakeoverRunResult<T> = {
-    readonly status: 'acquired';
-    readonly sessionId: string;
-    readonly epoch: number;
-    readonly result: T;
-} | {
-    readonly status: 'busy';
-    readonly epoch: number;
-};
-export declare function readParticipantOwner(squarePath: string, name: string, hostLedger: HostLedgerPort): Promise<PresenceRecord | undefined>;
-export declare function sessionOwnsParticipant(squarePath: string, name: string, sessionId: string, hostLedger: HostLedgerPort, expectedEpoch?: number): Promise<boolean>;
-export declare function releaseSessionParticipantClaim(hostLedger: HostLedgerPort, claim: OwnershipClaim): Promise<void>;
-export declare function claimSessionParticipant(squarePath: string, name: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<OwnershipClaim>;
-/**
- * Fenced takeover: the ownership claim and the lifecycle run as one critical section under the
- * 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 declare function claimSessionTakeover<T>(squarePath: string, name: string, hostLedger: HostLedgerPort, env: NodeJS.ProcessEnv | undefined, opts: {
-    readonly expectedEpoch?: number;
-    readonly expectedSession?: string;
-} | undefined, lifecycle: (claim: TakeoverClaimToken) => Promise<T>, signal?: AbortSignal): Promise<TakeoverRunResult<T>>;
-export declare function releaseSessionParticipant(squarePath: string, name: string, hostLedger: HostLedgerPort, env?: NodeJS.ProcessEnv): Promise<void>;
-export interface LocalSessionIdentity {
-    sessionId: string;
-    channel: PresenceChannel;
-    child: boolean;
-    paseoAgentId?: string;
-}
-export declare function localSessionIdentities(env?: NodeJS.ProcessEnv): LocalSessionIdentity[];
-export declare function hasAutomaticDeliveryIdentity(env?: NodeJS.ProcessEnv): boolean;
-/** Bind the host ledger to the caller's captured environment. */
-export declare function hostLedgerForEnv(env?: NodeJS.ProcessEnv): FileHostLedgerPort;

package/dist/registry.js

@@ -1,123 +0,0 @@
-/** 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';
-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;
-}
-/** The current owner: the highest epoch wins, then the most recently updated row. */
-export function currentOwner(rows) {
-    return [...rows].sort((left, right) => presenceEpoch(right) - presenceEpoch(left) || (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0];
-}
-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, 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, hostLedger, expectedEpoch) {
-    const owner = await readParticipantOwner(squarePath, name, hostLedger);
-    if (owner === undefined || owner.session !== sessionId)
-        return false;
-    return expectedEpoch === undefined || presenceEpoch(owner) === expectedEpoch;
-}
-export async function releaseSessionParticipantClaim(hostLedger, claim) {
-    if (claim?.status !== 'acquired')
-        return;
-    await hostLedger.removePresenceIfUnchanged(claim.record);
-}
-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 canonicalPath(squarePath);
-    const result = await hostLedger.claimPresence({
-        location,
-        participant: name,
-        session: identity.sessionId,
-        channel: identity.channel,
-        updatedAt: Date.now(),
-        epoch: 1,
-    }, signal);
-    if (result.status === 'busy')
-        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
-    if (result.status === 'degraded')
-        throw result.error;
-    const record = result.record;
-    return { status: result.status, record, sessionId: record.session, epoch: presenceEpoch(record) };
-}
-/**
- * Fenced takeover: the ownership claim and the lifecycle run as one critical section under the
- * 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, 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 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?.session === opts.expectedSession);
-        if (!epochMatches || !sessionMatches) {
-            return { status: 'busy', epoch: currentEpoch };
-        }
-        const epoch = currentEpoch + 1;
-        let result;
-        try {
-            result = await lifecycle({ sessionId: identity.sessionId, epoch });
-        }
-        catch (error) {
-            // Withdraw: the claim itself persisted nothing. Remove only rows carrying this exact claim
-            // 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 hostLedger.listPresence({ location, participant: name, session: identity.sessionId });
-            for (const row of tokenRows) {
-                if (row.channel === identity.channel && presenceEpoch(row) === epoch)
-                    await hostLedger.removePresence({ location: row.location, participant: row.participant, session: row.session, channel: row.channel });
-            }
-            for (const row of standing)
-                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 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, hostLedger, env = process.env) {
-    const identity = localSessionIdentities(env)[0];
-    if (identity === undefined)
-        return;
-    await hostLedger.removePresence({ location: squarePath, participant: name, session: identity.sessionId, channel: identity.channel });
-}
-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 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; }
-/** Bind the host ledger to the caller's captured environment. */
-export function hostLedgerForEnv(env = process.env) { return createHostLedgerPort({ rootPath: hostLedgerRoot(env) }); }

package/dist/routes.d.ts

@@ -1,39 +0,0 @@
-import { type WakeRoute, type WakeRouteKind } from './model.js';
-import type { SquareRead, SquareWrite } from './ports.js';
-export { WAKE_ROUTE_KINDS } from './model.js';
-export type { WakeRoute, WakeRouteKind } from './model.js';
-export declare const ROUTE_FRESH_MS: number;
-export type WakeBoundaryProvider = 'codex' | 'claude' | 'opencode' | 'pi' | 'paseo';
-export interface WakeBoundary {
-    readonly location: string;
-    readonly participant: string;
-    readonly sessionId: string;
-    readonly provider: WakeBoundaryProvider;
-}
-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 resolvePrimaryWakeRoute(boundary: WakeBoundary, env: NodeJS.ProcessEnv, capabilities: WakeRouteCapabilities): Omit<WakeRoute, 'updatedAt'> | undefined;
-export declare function routeIdentityKey(route: Pick<WakeRoute, 'location' | 'participant' | 'sessionId'>, location?: string): string;
-export type RouteEpoch = {
-    readonly epoch?: number;
-};
-export declare function applyWakeRoute(facts: SquareWrite, route: Omit<WakeRoute, 'updatedAt'> & RouteEpoch, at?: number): void;
-export declare function dropSessionWakeRoutes(facts: SquareWrite, location: string, sessionId: string, expectedEpoch?: number): void;
-/** Keep an in-flight same-session rejoin; unknown host evidence is not a reason to retire it. */
-export declare function dropEndedSessionWakeRoutes(facts: SquareWrite, location: string, sessionId: string, opts: {
-    readonly expectedEpoch?: number;
-    readonly liveParticipants?: ReadonlySet<string>;
-    readonly force: boolean;
-    readonly participant?: string;
-}): void;
-export declare function dropParticipantWakeRoutes(facts: SquareWrite, location: string, participant: string): void;
-export declare function sessionCanEndParticipant(facts: SquareRead, location: string, participant: string, sessionId: string, sessionIdNow?: 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 retireWakeRouteFromArtifact(artifact: import('./ports.js').SquareArtifactPort, route: Pick<WakeRoute, 'location' | 'participant' | 'sessionId'>, opts?: {
-    readonly expectedEpoch?: number;
-}): Promise<void>;