@astrosheep/square 0.3.23 → 0.3.25

package/dist/wake-evidence.js

@@ -1,38 +1,92 @@
-import { hasPresentedAttention } from './presented.js';
-import { lookupParticipant } from './registry.js';
+import { deriveDeliveryModel } from './delivery.js';
+import { nameKey } from './model.js';
+import { readPresentedAttentions } from './presented.js';
+import { canonicalSquarePath, readActiveBindings } from './registry.js';
 import { readWakeRoutes } from './routes.js';
 import { isWakeRouteAttemptable, readWakeAttempts, terminalWakeEvidence, } from './wake-attempts.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { notificationEvidence } from './views.js';
-/** Project every wake decision from the same primary evidence. */
-export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+import { observationFor } from './runtime.js';
+import { entryPresentation } from './views.js';
+function attentionKey(squarePath, recipient, actIndex) {
+    return JSON.stringify([canonicalSquarePath(squarePath), nameKey(recipient), actIndex]);
+}
+function projectionFromState(squarePath, state, now, env, delivery = deriveDeliveryModel(state)) {
+    const canonicalPath = canonicalSquarePath(squarePath);
+    const owners = new Map();
+    for (const binding of readActiveBindings(now)) {
+        if (binding.squarePath !== canonicalPath)
+            continue;
+        const key = nameKey(binding.name);
+        const recipientOwners = owners.get(key) ?? new Set();
+        recipientOwners.add(binding.ownerId);
+        owners.set(key, recipientOwners);
+    }
+    const routesByOwner = new Map();
+    for (const route of readWakeRoutes({ freshOnly: true, now, env })) {
+        const routes = routesByOwner.get(route.ownerId) ?? [];
+        routes.push(route);
+        routesByOwner.set(route.ownerId, routes);
+    }
+    const attemptsByAttention = new Map();
+    for (const attempt of readWakeAttempts({ env, now })) {
+        const key = attentionKey(attempt.attention.squarePath, attempt.attention.recipient, attempt.attention.actIndex);
+        const attempts = attemptsByAttention.get(key) ?? [];
+        attempts.push(attempt);
+        attemptsByAttention.set(key, attempts);
+    }
+    const presentedByAttention = new Map();
+    for (const presented of readPresentedAttentions(env, now)) {
+        const key = attentionKey(presented.squarePath, presented.name, presented.actIndex);
+        const presentedOwners = presentedByAttention.get(key) ?? new Set();
+        presentedOwners.add(presented.ownerId);
+        presentedByAttention.set(key, presentedOwners);
+    }
+    return {
+        evidence(recipient, actIndex) {
+            const recipientOwners = owners.get(nameKey(recipient)) ?? new Set();
+            const key = attentionKey(squarePath, recipient, actIndex);
+            const attempts = attemptsByAttention.get(key) ?? [];
+            const terminal = terminalWakeEvidence(attempts);
+            const routes = [...recipientOwners].flatMap((ownerId) => routesByOwner.get(ownerId) ?? []);
+            const presented = [...(presentedByAttention.get(key) ?? [])]
+                .some((ownerId) => recipientOwners.has(ownerId));
+            return {
+                delivered: delivery.isSeen(recipient, actIndex),
+                notified: (() => {
+                    const observation = observationFor(state, recipient, actIndex);
+                    return observation?.state === 'notified'
+                        && observation.ownerId !== undefined
+                        && recipientOwners.has(observation.ownerId);
+                })(),
+                presented,
+                attempts,
+                ...(terminal === undefined ? {} : { terminal }),
+                attemptableRoutes: terminal === undefined
+                    ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
+                    : [],
+            };
+        },
+    };
+}
+/** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
+export async function wakeEvidenceProjection(squarePath, now, env) {
     const square = await openSquare(squarePath, { clock: () => now });
     try {
-        const { delivered, observation } = await notificationEvidence(square, recipient, actIndex);
-        const owners = new Set(lookupParticipant(squarePath, recipient, now).map((binding) => binding.ownerId));
-        const notified = observation?.state === 'notified'
-            && observation.ownerId !== undefined
-            && owners.has(observation.ownerId);
-        const attempts = readWakeAttempts({ attention: { squarePath, recipient, actIndex }, env, now });
-        const terminal = terminalWakeEvidence(attempts);
-        const routes = readWakeRoutes({ freshOnly: true, now, env })
-            .filter((route) => owners.has(route.ownerId));
-        return {
-            delivered,
-            notified,
-            presented: hasPresentedAttention(squarePath, recipient, actIndex, env, now),
-            attempts,
-            ...(terminal === undefined ? {} : { terminal }),
-            attemptableRoutes: terminal === undefined
-                ? routes.filter((route) => isWakeRouteAttemptable(route, attempts))
-                : [],
-        };
+        const { state } = await entryPresentation(square, '');
+        return projectionFromState(squarePath, state, now, env);
     }
     finally {
         await closeOpenSquare(square);
     }
 }
+export function wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery) {
+    return projectionFromState(squarePath, state, now, env, delivery);
+}
+/** Project every wake decision from the same primary evidence. */
+export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {
+    return (await wakeEvidenceProjection(squarePath, now, env)).evidence(recipient, actIndex);
+}
 export function wakeIsEligible(evidence) {
     return !evidence.delivered
         && !evidence.notified

package/dist/watch.d.ts

@@ -1,2 +1,3 @@
 import { type WatchOptions } from './model.js';
-export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions): Promise<void>;
+/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
+export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions): Promise<boolean | undefined>;

package/dist/watch.js

@@ -19,10 +19,15 @@ function watchOutputResult(squarePath, presentation, name, caught, opts = {}) {
     const delivered = caught.activities.flatMap((activity) => {
         const index = parseActivityId(activity.id);
         const stored = index === undefined ? undefined : presentation.activities.find((item) => item.index === index);
-        return stored === undefined ? [] : [stored];
+        return stored === undefined ? [] : [{ activity: stored, perception: activity.perception }];
     });
-    const publicItems = delivered.filter((item) => item.kind === 'say' || item.kind === 'done');
-    const roomChanges = delivered.filter((item) => item.kind === 'join' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume');
+    const publicItems = delivered
+        .map(({ activity }) => activity)
+        .filter((item) => item.kind === 'say' || item.kind === 'done');
+    const roomChanges = delivered
+        .map(({ activity }) => activity)
+        .filter((item) => item.kind === 'join' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume');
+    const perceptions = new Map(delivered.map(({ activity, perception }) => [activity.index, perception]));
     return {
         type: 'output',
         stdout: renderWatchOutput([...presentation.activities], publicItems, roomChanges, {
@@ -30,7 +35,7 @@ function watchOutputResult(squarePath, presentation, name, caught, opts = {}) {
             squarePath,
             viewer: name,
             showCatchHint: !hasAutomaticDeliveryIdentity(),
-            squareState: presentation.state,
+            perceptions,
         }),
         ...(opts.status ? { status: opts.status } : {}),
     };
@@ -118,12 +123,14 @@ async function cmdWatchNow(squarePath, name, opts) {
             ? watchOutputResult(squarePath, presentation, name, caught, { mention: opts.mention, ...(status ? { status } : {}) })
             : { type: 'terminal', status: status ?? 'empty-now' };
         await finishWatchResult(square, squarePath, name, result, undefined);
+        return caught.activities.length > 0;
     }
     finally {
         await facade.close();
         await closeOpenSquare(square);
     }
 }
+/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
 export async function cmdWatch(squarePath, name, opts) {
     let square;
     try {
@@ -144,8 +151,7 @@ export async function cmdWatch(squarePath, name, opts) {
     }
     if (opts.now) {
         await closeOpenSquare(square);
-        await cmdWatchNow(squarePath, name, opts);
-        return;
+        return cmdWatchNow(squarePath, name, opts);
     }
     const start = await beginWatch(square, squarePath, name, opts);
     if (start.type === 'active') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.23",
+  "version": "0.3.25",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {