@astrosheep/square 0.3.30 → 0.3.32

package/dist/landing.js

@@ -1,126 +1,42 @@
-import { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
-import { coreDone, coreHold, coreIgnore, coreListen, coreListening, coreResume, decideAct, decideImplicitJoin, decideJoin } from './decisions.js';
-import { deriveDeliveryModel } from './delivery.js';
-import { SquareError } from './model.js';
-import { participantIdentity } from './participant-identity.js';
-function storeActs(state, acts) {
-    const stored = [];
-    for (const act of acts) {
-        const item = { ...act, index: state.runtime.nextActIndex };
-        state.runtime.nextActIndex += 1;
-        state.acts.push(item);
-        stored.push(item);
-    }
-    return stored;
-}
-function committedActivity(stored, verb) {
-    const activity = stored[0];
-    if (activity === undefined)
-        throw new Error(`${verb} activity did not commit`);
-    return activity;
-}
-function exposeActivity(stored) {
-    if (stored.kind === 'read' || stored.actor === undefined)
-        throw new Error(`Cannot expose stored activity ${formatActivityId(stored.index)}`);
+import { done as applyDone, express as applyExpress, hold as applyHold, ignore as applyIgnore, implicitJoin as applyImplicitJoin, join as applyJoin, listen as applyListen, listening as applyListening, resume as applyResume, } from './square-actions.js';
+function artifactOf(square) {
+    if ('artifact' in square)
+        return square.artifact;
+    const { cell } = square;
     return {
-        id: formatActivityId(stored.index), at: stored.at, kind: stored.kind, actor: stored.actor,
-        ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}),
-        mentions: stored.kind === 'say' ? extractMentions(stored.body) : [],
-        ...('target' in stored ? { target: stored.target } : {}),
-        ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}),
+        read: () => cell.read(),
+        transact: (fn) => cell.transact(fn),
+        changed: (sinceVersion, timeoutMs) => cell.changed(sinceVersion, timeoutMs),
+        close: () => cell.close(),
     };
 }
-function parseRequiredActivityId(id) {
-    const index = parseActivityId(id);
-    if (index === undefined)
-        throw new SquareError('invalid_args', `Invalid activity id: ${id}`);
-    return index;
-}
-async function wakeAfterCommit(square, recipients, activity) {
-    if (recipients.length === 0)
-        return;
-    try {
-        square.notifier?.wake(recipients, activity);
-    }
-    catch { /* post-commit effects cannot undo activities */ }
+function contextOf(square) {
+    return { artifact: artifactOf(square), clock: square.clock, ...('location' in square ? { location: square.location, hostLedger: square.hostLedger, env: square.env } : {}) };
 }
-export async function join(square, name) {
-    const now = square.clock();
-    const committed = await square.cell.transact((state) => {
-        const decision = decideJoin(state, name, now);
-        if (decision.joinAct === undefined)
-            return { result: { name: decision.joinedName, stored: null } };
-        return { state, result: { name: decision.joinedName, stored: committedActivity(storeActs(state, [decision.joinAct]), 'join') } };
-    });
-    return { name: committed.name, activity: committed.stored === null ? null : exposeActivity(committed.stored) };
+export function join(square, name) {
+    return applyJoin(contextOf(square), name);
 }
-/** Automatic presence distinguishes first entry, current presence, and completed presence. */
-export async function implicitJoin(square, name) {
-    const now = square.clock();
-    const committed = await square.cell.transact((state) => {
-        const decision = decideImplicitJoin(state, name, now);
-        if (decision.joinAct === undefined)
-            return { result: { name: decision.joinedName, state: decision.state, stored: null } };
-        return { state, result: { name: decision.joinedName, state: decision.state, stored: committedActivity(storeActs(state, [decision.joinAct]), 'join') } };
-    });
-    return { name: committed.name, state: committed.state, activity: committed.stored === null ? null : exposeActivity(committed.stored) };
+export function implicitJoin(square, name) {
+    return applyImplicitJoin(contextOf(square), name);
 }
-export async function express(square, name, body, options = {}) {
-    const now = square.clock();
-    const reply = options.reply === undefined ? undefined : parseRequiredActivityId(options.reply);
-    const committed = await square.cell.transact((state) => {
-        const decision = decideAct(state, { name, body, force: options.force ?? false, now, ...(options.reach === undefined ? {} : { reach: options.reach }), ...(reply === undefined ? {} : { reply }) });
-        if (decision.type === 'blocked') {
-            const pending = decision.activitySummaries.reduce((count, summary) => count + summary.count, 0) + decision.unreadRoomChanges.length;
-            throw new SquareError('behind', `${participantIdentity(name)} has pending activity`, { pending });
-        }
-        if (decision.type === 'held') {
-            const holder = state.acts.filter((activity) => activity.kind === 'hold').at(-1)?.actor;
-            throw new SquareError('held', 'The square is held', holder === undefined ? undefined : { holder });
-        }
-        if (decision.type === 'capped')
-            throw new SquareError('capped', `${participantIdentity(name)} reached the activity cap`);
-        if (decision.type === 'throttled')
-            throw new SquareError('throttled', `${name} is throttled`, { retryAfterMs: decision.delayMs });
-        if (decision.type === 'bell_quota')
-            throw new SquareError('bell_quota', `${participantIdentity(name)} cannot ring the bell yet`, { retryAfterMs: Math.max(1, decision.nextAt - now) });
-        const stored = committedActivity(storeActs(state, [decision.act]), 'express');
-        return { state, result: { stored, recipients: deriveDeliveryModel(state).plan(stored).map((notification) => notification.recipient) } };
-    });
-    const activity = exposeActivity(committed.stored);
-    await wakeAfterCommit(square, committed.recipients, activity);
-    return { activity };
-}
-async function landListenerChange(square, verb, actor, target) {
-    const now = square.clock();
-    const stored = await square.cell.transact((state) => {
-        const act = verb === 'listen'
-            ? coreListen(state, actor, target, now)
-            : coreIgnore(state, actor, target, now);
-        if (act === undefined)
-            return { result: null };
-        return { state, result: committedActivity(storeActs(state, [act]), verb) };
-    });
-    return { activity: stored === null ? null : exposeActivity(stored) };
+export function express(square, name, body, options) {
+    return applyExpress(contextOf(square), name, body, options);
 }
 export function listen(square, actor, target) {
-    return landListenerChange(square, 'listen', actor, target);
+    return applyListen(contextOf(square), actor, target);
 }
 export function ignore(square, actor, target) {
-    return landListenerChange(square, 'ignore', actor, target);
+    return applyIgnore(contextOf(square), actor, target);
+}
+export function listening(square, actor) {
+    return applyListening(contextOf(square), actor);
+}
+export function done(square, name, body = '') {
+    return applyDone(contextOf(square), name, body);
 }
-export async function listening(square, actor) {
-    const { state } = await square.cell.read();
-    return coreListening(state, actor);
+export function hold(square, name, reason = '') {
+    return applyHold(contextOf(square), name, reason);
 }
-async function landCore(square, verb, actor, body = '') {
-    const now = square.clock();
-    const stored = await square.cell.transact((state) => {
-        const act = verb === 'done' ? coreDone(state, actor, body, now) : verb === 'hold' ? coreHold(state, actor, body, now) : coreResume(state, actor, now);
-        return { state, result: committedActivity(storeActs(state, [act]), verb) };
-    });
-    return { activity: exposeActivity(stored) };
+export function resume(square, name) {
+    return applyResume(contextOf(square), name);
 }
-export function done(square, name, body = '') { return landCore(square, 'done', name, body); }
-export function hold(square, name, reason = '') { return landCore(square, 'hold', name, reason); }
-export function resume(square, name) { return landCore(square, 'resume', name); }

package/dist/model.d.ts

@@ -5,12 +5,16 @@ export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {
-    ownerId: string;
+    location: string;
+    participant: string;
     sessionId: string;
+    channel: string;
     kind: WakeRouteKind;
     address: Record<string, string>;
     updatedAt: number;
 }
+export interface ReceiverRoute extends WakeRoute {
+}
 export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'held' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
 export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
 export interface SquareErrorFacts {
@@ -40,11 +44,10 @@ export type StoredAct = Act & {
     at: number;
 };
 export type StoredActHead = StoredAct extends infer T ? T extends StoredAct ? Omit<T, 'body' | 'through' | 'index'> : never : never;
-export type ObservationState = 'notified' | 'seen';
+export type ObservationState = 'seen';
 export interface ActivityObservation {
     state: ObservationState;
     at: number;
-    ownerId?: string;
 }
 export interface WatchLeaseFilter {
     participants?: string[];
@@ -52,8 +55,6 @@ export interface WatchLeaseFilter {
 }
 export interface WatchLease {
     leaseId: string;
-    /** Machine-local owner that may claim automatic delivery for this lease. */
-    ownerId?: string;
     heartbeatAt: number;
     expiresAt: number;
     filter?: WatchLeaseFilter;
@@ -69,22 +70,13 @@ export interface InboxNotification {
 export interface InboxMembership {
     name: string;
     squarePath: string;
-    ownerId?: string;
     notifications: InboxNotification[];
     catchLease?: WatchLease;
 }
-export interface NotifyLease {
-    leaseId: string;
-    expiresAt: number;
-    phase: 'claimed' | 'dispatching';
-    attemptN?: number;
-    routeKind?: WakeRouteKind;
-}
 export interface SquareRuntimeState {
     nextActIndex: number;
     observations: Record<string, Record<string, ActivityObservation>>;
     leases: Record<string, WatchLease>;
-    notifyLeases: Record<string, NotifyLease>;
 }
 export interface SquareState {
     hardCap: HardCap;
@@ -92,17 +84,18 @@ export interface SquareState {
     preamble: string[];
     warmup: string[];
     acts: StoredAct[];
+    routes?: ReceiverRoute[];
     runtime: SquareRuntimeState;
 }
 export interface ActivitiesOptions {
     lastN?: number | null;
     participants?: string[];
-    /** Exclusive upper bound on act.at (ms). */
-    before?: number;
     /** Exclusive lower bound on act.at (ms). Alias of --since. */
     after?: number;
     /** Exclusive lower bound on stable act index (--after act/<index>). */
     afterIndex?: number;
+    /** Exclusive upper bound on stable act index (--before act/<index>). */
+    beforeIndex?: number;
     /** Center act indexes for context windows (--at). */
     atIndexes?: number[];
     beforeContext?: number;
@@ -111,7 +104,6 @@ export interface ActivitiesOptions {
     /** Undelivered mention/bell items for viewer only (read-only; requires viewer). */
     pending?: boolean;
     viewer?: string;
-    full?: boolean;
     grep?: string;
     fixed?: string;
     order?: 'asc' | 'desc';

package/dist/model.js

@@ -40,7 +40,7 @@ export function findParticipantName(participants, name) {
     return participants.find((participant) => sameName(participant, name));
 }
 export function validateName(name) {
-    if (!name || !/^[\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)*$/u.test(name)) {
-        throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using only Unicode letters, digits, hyphens, and underscores.');
+    if (!name || !/^(?:[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]|\p{RGI_Emoji})+(?:\/(?:[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]|\p{RGI_Emoji})+)*$/v.test(name)) {
+        throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using Unicode letters, digits, marks, hyphens, underscores, or complete RGI emoji graphemes.');
     }
 }

package/dist/notifications.d.ts

@@ -1,8 +1,8 @@
-import { planActNotifications, type DeliveryModel, type WakeAdapter } from './delivery.js';
+import { planActNotifications, type WakeAdapter } from './delivery.js';
 import { type SquareState } from './model.js';
 import { matchesMentionTarget } from './runtime.js';
 import { type ActivityId } from './square-core.js';
-import type { WakeNotifier } from './square-facade.js';
+import type { WakeTransportPort } from './ports.js';
 export type { PlannedNotification } from './delivery.js';
 export { planActNotifications, matchesMentionTarget };
 export { notificationMessageId } from './delivery.js';
@@ -17,17 +17,19 @@ interface ProcessNotificationOptions {
     env?: NodeJS.ProcessEnv;
     now?: () => number;
 }
-export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<void>;
-interface WorkerLaunchOptions {
-    launchWorker?: (workerPath: string, args: string[]) => void;
+export declare function defaultWakeAdapters(): Promise<WakeAdapter[]>;
+export declare function createDefaultWakeTransport(hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number, env?: NodeJS.ProcessEnv): Promise<WakeTransportPort>;
+export declare function createWakeTransport(adapters: readonly WakeAdapter[], hostLedger: import('./host-ledger.js').HostLedgerPort, clock: () => number): WakeTransportPort;
+export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
+/** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares. */
+export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedAdapters?: WakeAdapter[]): Promise<void>;
+export interface SweepPendingNotificationsOptions {
     env?: NodeJS.ProcessEnv;
-}
-export declare function wakeNotifierForSquare(squarePath: string, env?: NodeJS.ProcessEnv): WakeNotifier;
-export interface SweepPendingNotificationsOptions extends WorkerLaunchOptions {
     now?: number;
     limit?: number;
+    dispatchCandidate?: (actIndex: number) => void | Promise<void>;
 }
 /** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): Promise<number[]>;
-/** Reconsider old pending attention at a bounded action boundary using the existing worker. */
+export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: import('./model.js').SquareState) => ReturnType<typeof import('./delivery.js').deriveDeliveryModel>): Promise<number[]>;
+/** Select old pending attention at a bounded action boundary for an explicit executor. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;