@astrosheep/square 0.3.27 → 0.3.29

package/dist/presented.js

@@ -1,23 +1,19 @@
-import fs from 'node:fs';
+import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-import { withFileLock, withFileLockSync } from './file-lock.js';
+import { withFileLock } from './file-lock.js';
 import { canonicalSquarePath, lookupParticipant, lookupSessionBindings } from './registry.js';
 import { sameName } from './model.js';
 const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 const LOCK_STALE_MS = 5 * 60_000;
 const LOCK_RETRY_MS = 10;
-export function presentedPath(env = process.env) {
-    return env.SQUARE_PRESENTED || path.join(os.homedir(), '.square', 'presented.ndjsonl');
-}
-function rowKey(row) {
-    return `${row.owner_id}\u0000${canonicalSquarePath(row.square_path)}\u0000${row.name.toLocaleLowerCase()}\u0000${row.act_index}`;
-}
-function readRows(filePath, now = Date.now()) {
+export function presentedPath(env = process.env) { return env.SQUARE_PRESENTED || path.join(os.homedir(), '.square', 'presented.ndjsonl'); }
+async function rowKey(row) { return `${row.owner_id}\u0000${await canonicalSquarePath(row.square_path)}\u0000${row.name.toLocaleLowerCase()}\u0000${row.act_index}`; }
+async function readRows(filePath, now = Date.now()) {
     let text;
     try {
-        text = fs.readFileSync(filePath, 'utf8');
+        text = await fs.readFile(filePath, 'utf8');
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -31,158 +27,52 @@ function readRows(filePath, now = Date.now()) {
             continue;
         try {
             const parsed = JSON.parse(line);
-            if (parsed.v !== 2 ||
-                typeof parsed.ts !== 'number' || !Number.isFinite(parsed.ts) ||
-                typeof parsed.owner_id !== 'string' ||
-                typeof parsed.square_path !== 'string' ||
-                typeof parsed.name !== 'string' ||
-                typeof parsed.act_index !== 'number' ||
-                parsed.ts < cutoff) {
+            if (parsed.v !== 2 || typeof parsed.ts !== 'number' || !Number.isFinite(parsed.ts) || typeof parsed.owner_id !== 'string' || typeof parsed.square_path !== 'string' || typeof parsed.name !== 'string' || typeof parsed.act_index !== 'number' || parsed.ts < cutoff)
                 continue;
-            }
             rows.push(parsed);
         }
-        catch {
-            // The presented ledger is a disposable cache; malformed rows are ignored.
-        }
+        catch { }
     }
     return rows;
 }
-/** Read the current presentation facts once for a derived evidence projection. */
-export function readPresentedAttentions(env = process.env, now = Date.now()) {
-    return readRows(presentedPath(env), now).map((row) => ({
-        ownerId: row.owner_id,
-        squarePath: canonicalSquarePath(row.square_path),
-        name: row.name,
-        actIndex: row.act_index,
-    }));
-}
-function writeRows(filePath, rows) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temp, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), {
-        mode: 0o600,
-    });
-    fs.renameSync(temp, filePath);
-}
-function membershipKey(membership) {
-    return `${canonicalSquarePath(membership.squarePath)}\u0000${membership.name.toLocaleLowerCase()}`;
-}
-function attentionLockPath(filePath, membership) {
-    const digest = createHash('sha256').update(membershipKey(membership)).digest('hex');
-    return `${filePath}.${digest}.lock`;
-}
-function withAttentionLocks(filePath, inbox, fn) {
-    const lockPaths = [...new Set(inbox.map((membership) => attentionLockPath(filePath, membership)))].sort();
-    function acquire(index) {
-        if (index >= lockPaths.length)
-            return fn();
-        return withFileLockSync(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => acquire(index + 1));
-    }
-    return acquire(0);
-}
-async function withAttentionLocksAsync(filePath, inbox, fn) {
-    const lockPaths = [...new Set(inbox.map((membership) => attentionLockPath(filePath, membership)))].sort();
-    async function acquire(index) {
-        if (index >= lockPaths.length)
-            return fn();
-        return withFileLock(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => acquire(index + 1));
+export async function readPresentedAttentions(env = process.env, now = Date.now()) { return Promise.all((await readRows(presentedPath(env), now)).map(async (row) => ({ ownerId: row.owner_id, squarePath: await canonicalSquarePath(row.square_path), name: row.name, actIndex: row.act_index }))); }
+async function writeRows(filePath, rows) { await fs.mkdir(path.dirname(filePath), { recursive: true }); const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`; await fs.writeFile(temp, rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : ''), { mode: 0o600 }); await fs.rename(temp, filePath); }
+async function membershipKey(membership) { return `${await canonicalSquarePath(membership.squarePath)}\u0000${membership.name.toLocaleLowerCase()}`; }
+async function attentionLockPath(filePath, membership) { return `${filePath}.${createHash('sha256').update(await membershipKey(membership)).digest('hex')}.lock`; }
+async function withAttentionLocks(filePath, inbox, fn, signal) { const lockPaths = [...new Set(await Promise.all(inbox.map((membership) => attentionLockPath(filePath, membership))))].sort(); async function acquire(index) { if (signal?.aborted)
+    throw signal.reason ?? new Error('Presentation aborted'); if (index >= lockPaths.length)
+    return fn(); return withFileLock(lockPaths[index], { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS, signal }, () => acquire(index + 1)); } return acquire(0); }
+async function ownerFor(sessionId, membership) { const squarePath = await canonicalSquarePath(membership.squarePath); const binding = (await lookupSessionBindings(sessionId)).find((candidate) => candidate.squarePath === squarePath && sameName(candidate.name, membership.name)); return binding?.ownerId ?? `session:${sessionId}`; }
+async function selectUnpresented(sessionId, inbox, rows) { const known = new Set(await Promise.all(rows.map(rowKey))); const selected = []; for (const membership of inbox) {
+    const ownerId = await ownerFor(sessionId, membership);
+    const notifications = [];
+    for (const notification of membership.notifications) {
+        if (!known.has(await rowKey({ owner_id: ownerId, square_path: membership.squarePath, name: membership.name, act_index: notification.actIndex })))
+            notifications.push(notification);
     }
-    return acquire(0);
-}
-function ownerFor(sessionId, membership) {
-    const squarePath = canonicalSquarePath(membership.squarePath);
-    const binding = lookupSessionBindings(sessionId).find((candidate) => candidate.squarePath === squarePath && sameName(candidate.name, membership.name));
-    return binding?.ownerId ?? `session:${sessionId}`;
-}
-function selectUnpresented(sessionId, inbox, rows) {
-    const known = new Set(rows.map(rowKey));
-    return inbox.flatMap((membership) => {
-        const ownerId = ownerFor(sessionId, membership);
-        const notifications = membership.notifications.filter((notification) => !known.has(rowKey({
-            owner_id: ownerId,
-            square_path: membership.squarePath,
-            name: membership.name,
-            act_index: notification.actIndex,
-        })));
-        return notifications.length === 0
-            ? []
-            : [{ membership: { ...membership, notifications }, ownerId }];
-    });
-}
-export function hasPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, now = Date.now()) {
-    const resolved = canonicalSquarePath(squarePath);
-    return readRows(presentedPath(env), now).some((row) => row.owner_id === ownerId &&
-        canonicalSquarePath(row.square_path) === resolved &&
-        sameName(row.name, name) &&
-        row.act_index === actIndex);
-}
-/** True when any current participant owner has already received this attention. */
-export function hasPresentedAttention(squarePath, name, actIndex, env = process.env, now = Date.now()) {
-    const ownerIds = new Set(lookupParticipant(squarePath, name, now).map((binding) => binding.ownerId));
-    if (ownerIds.size === 0)
-        return false;
-    return [...ownerIds].some((ownerId) => hasPresentedForOwner(ownerId, squarePath, name, actIndex, env, now));
-}
-/** Record presentation by a transport that delivered the bounded attention body. */
-export function recordPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, at = Date.now()) {
-    const filePath = presentedPath(env);
-    const row = {
-        v: 2,
-        ts: at,
-        owner_id: ownerId,
-        square_path: canonicalSquarePath(squarePath),
-        name,
-        act_index: actIndex,
-    };
-    withAttentionLocks(filePath, [{ name, squarePath, notifications: [] }], () => {
-        withFileLockSync(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
-            const rows = readRows(filePath, at);
-            const known = new Set(rows.map(rowKey));
-            if (!known.has(rowKey(row)))
-                writeRows(filePath, [...rows, row]);
-        });
-    });
-}
-/**
- * Serialize presentation only for the affected participants. Delivery runs
- * outside the short ledger-write lock, so unrelated owners never wait on an
- * adapter. A throwing or rejecting callback leaves no row and remains unpresented.
- */
-export async function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now()) {
-    const filePath = presentedPath(env);
-    const initial = (await lookup(sessionId)).filter((membership) => membership.notifications.length > 0);
-    if (initial.length === 0)
-        return undefined;
-    const lockedMemberships = new Set(initial.map(membershipKey));
-    return withAttentionLocksAsync(filePath, initial, async () => {
-        const current = (await lookup(sessionId)).filter((membership) => lockedMemberships.has(membershipKey(membership)));
-        const selected = selectUnpresented(sessionId, current, readRows(filePath, at));
-        if (selected.length === 0)
-            return undefined;
-        const result = await deliver(selected.map(({ membership }) => membership));
-        await withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
-            const rows = readRows(filePath, at);
-            const known = new Set(rows.map(rowKey));
-            for (const { membership, ownerId } of selected) {
-                for (const notification of membership.notifications) {
-                    const row = {
-                        v: 2,
-                        ts: at,
-                        owner_id: ownerId,
-                        square_path: canonicalSquarePath(membership.squarePath),
-                        name: membership.name,
-                        act_index: notification.actIndex,
-                    };
-                    const key = rowKey(row);
-                    if (known.has(key))
-                        continue;
-                    rows.push(row);
-                    known.add(key);
-                }
-            }
-            writeRows(filePath, rows);
-        });
-        return result;
-    });
-}
+    if (notifications.length > 0)
+        selected.push({ membership: { ...membership, notifications }, ownerId });
+} return selected; }
+export async function hasPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, now = Date.now()) { const resolved = await canonicalSquarePath(squarePath); for (const row of await readRows(presentedPath(env), now))
+    if (row.owner_id === ownerId && await canonicalSquarePath(row.square_path) === resolved && sameName(row.name, name) && row.act_index === actIndex)
+        return true; return false; }
+export async function hasPresentedAttention(squarePath, name, actIndex, env = process.env, now = Date.now()) { const ownerIds = new Set((await lookupParticipant(squarePath, name, now)).map((binding) => binding.ownerId)); for (const ownerId of ownerIds)
+    if (await hasPresentedForOwner(ownerId, squarePath, name, actIndex, env, now))
+        return true; return false; }
+export async function recordPresentedForOwner(ownerId, squarePath, name, actIndex, env = process.env, at = Date.now()) { const filePath = presentedPath(env); const row = { v: 2, ts: at, owner_id: ownerId, square_path: await canonicalSquarePath(squarePath), name, act_index: actIndex }; await withAttentionLocks(filePath, [{ name, squarePath, notifications: [] }], () => withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, async () => { const rows = await readRows(filePath, at); const known = new Set(await Promise.all(rows.map(rowKey))); if (!known.has(await rowKey(row)))
+    await writeRows(filePath, [...rows, row]); })); }
+export async function presentOnce(sessionId, lookup, deliver, env = process.env, at = Date.now(), signal) { const filePath = presentedPath(env); const initial = (await lookup(sessionId)).filter((membership) => membership.notifications.length > 0); if (initial.length === 0)
+    return undefined; const lockedMemberships = new Set(await Promise.all(initial.map(membershipKey))); return withAttentionLocks(filePath, initial, async () => { const current = []; for (const membership of await lookup(sessionId))
+    if (lockedMemberships.has(await membershipKey(membership)))
+        current.push(membership); const selected = await selectUnpresented(sessionId, current, await readRows(filePath, at)); if (selected.length === 0)
+    return undefined; if (signal?.aborted)
+    throw signal.reason ?? new Error('Presentation aborted'); const result = await deliver(selected.map(({ membership }) => membership)); if (signal?.aborted)
+    throw signal.reason ?? new Error('Presentation aborted'); await withFileLock(`${filePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS, signal }, async () => { const rows = await readRows(filePath, at); const known = new Set(await Promise.all(rows.map(rowKey))); for (const { membership, ownerId } of selected)
+    for (const notification of membership.notifications) {
+        const row = { v: 2, ts: at, owner_id: ownerId, square_path: await canonicalSquarePath(membership.squarePath), name: membership.name, act_index: notification.actIndex };
+        const key = await rowKey(row);
+        if (!known.has(key)) {
+            rows.push(row);
+            known.add(key);
+        }
+    } await writeRows(filePath, rows); }); return result; }, signal); }

package/dist/registry.d.ts

@@ -1,10 +1,4 @@
-/**
- * Machine-local participant discovery cache.
- *
- * The Square artifact remains authoritative for membership. This append-only
- * cache only maps native harness sessions and optional Paseo agent ids back to
- * active (square path, participant name) pairs.
- */
+/** Machine-local participant discovery cache. */
 import { type StoredAct } from './model.js';
 export type SessionChannel = 'claude-code' | 'codex' | 'opencode' | 'pi' | 'paseo' | 'unknown';
 export interface RegistryBinding {
@@ -25,35 +19,30 @@ export interface RegistryWriteOptions {
     at?: number;
 }
 export declare function registryPath(): string;
-export declare function canonicalSquarePath(squarePath: string): string;
-export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
-export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): void;
-export declare function readActiveBindings(now?: number): RegistryBinding[];
-export declare function lookupSessionBindings(sessionId: string, now?: number): RegistryBinding[];
-export declare function lookupSession(sessionId: string, now?: number): Array<{
+export declare function canonicalSquarePath(squarePath: string): Promise<string>;
+export declare function recordJoin(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
+export declare function recordDone(sessionId: string, name: string, squarePath: string, options?: RegistryWriteOptions): Promise<void>;
+export declare function readActiveBindings(now?: number): Promise<RegistryBinding[]>;
+export declare function lookupSessionBindings(sessionId: string, now?: number): Promise<RegistryBinding[]>;
+export declare function lookupSession(sessionId: string, now?: number): Promise<Array<{
     name: string;
     squarePath: string;
-}>;
-export declare function lookupParticipant(squarePath: string, name: string, now?: number): RegistryBinding[];
-/** Resolve the current local harness owner for a participant, if one is registered. */
-export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): string | undefined;
-export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): string | undefined;
-/** Compute the current participant from the live harness identity, without registry history. */
+}>>;
+export declare function lookupParticipant(squarePath: string, name: string, now?: number): Promise<RegistryBinding[]>;
+export declare function localParticipantOwner(squarePath: string, name: string, env?: NodeJS.ProcessEnv, now?: number): Promise<string | undefined>;
+export declare function localParticipantName(squarePath: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
 export declare function squareAssignedParticipantName(env?: NodeJS.ProcessEnv): string | undefined;
 export type CurrentParticipantBinding = Readonly<{
     created: boolean;
     ownerId: string;
 }>;
-/** Bind the current harness to one explicit Square participant. */
-export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): CurrentParticipantBinding;
-/** Retire only this harness's binding for one Square participant. */
-export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function bindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<CurrentParticipantBinding>;
+export declare function unbindCurrentParticipant(squarePath: string, name: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
 export interface RegistryPruneResult {
     removed: number;
     kept: number;
 }
-/** Compact the registry and remove only bindings disproved by their authoritative artifact. */
-export declare function pruneRegistry(readActs: (squarePath: string) => StoredAct[] | undefined, now?: number): RegistryPruneResult;
+export declare function pruneRegistry(readActs: (squarePath: string) => StoredAct[] | undefined | Promise<StoredAct[] | undefined>, now?: number): Promise<RegistryPruneResult>;
 export interface LocalSessionIdentity {
     sessionId: string;
     channel: SessionChannel;
@@ -61,9 +50,8 @@ export interface LocalSessionIdentity {
     paseoAgentId?: string;
 }
 export declare function localSessionIdentities(env?: NodeJS.ProcessEnv): LocalSessionIdentity[];
-/** True when this process belongs to a harness that can deliver Square attention without a foreground catch. */
 export declare function hasAutomaticDeliveryIdentity(env?: NodeJS.ProcessEnv): boolean;
-export declare function recordLocalJoin(name: string, squarePath: string, env?: NodeJS.ProcessEnv): void;
-export declare function recordLocalDone(name: string, squarePath: string, env?: NodeJS.ProcessEnv): void;
-export declare function recordSessionJoin(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): string;
-export declare function recordSessionDone(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): boolean;
+export declare function recordLocalJoin(name: string, squarePath: string, env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function recordLocalDone(name: string, squarePath: string, env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function recordSessionJoin(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare function recordSessionDone(sessionId: string, name: string, squarePath: string, channel: SessionChannel, env?: NodeJS.ProcessEnv): Promise<boolean>;