@astrosheep/square 0.3.85 → 0.3.87

package/dist/square-stdio.js

@@ -0,0 +1,222 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+import { SquareError } from './model.js';
+import { harnessSessionSources } from './participant-identity.js';
+import { requireJoinName } from './seats.js';
+export const STDIO_PROTOCOL_VERSION = 1;
+export const STDIO_MAX_FRAME_BYTES = 8 * 1024 * 1024;
+export const identityVariables = [...harnessSessionSources.flatMap(source => [source.variable, ...(source.childVariable ? [source.childVariable] : [])])];
+export function wireIdentity(env) {
+    return Object.fromEntries(identityVariables.map(key => [key, env[key] ?? '']));
+}
+export function encodeError(error) {
+    const e = error;
+    return { code: -32000, message: e.message ?? 'Backend request failed', data: { code: e.code, facts: e.facts, operation: e.operation } };
+}
+function decodeError(error) {
+    return Object.assign(error.data?.code ? new SquareError(error.data.code, error.message, error.data.facts) : new Error(error.message), error.data?.operation ? { operation: error.data.operation } : {});
+}
+export function unsupported(feature) {
+    throw new SquareError('invalid_args', `The stdio backend does not support ${feature}; use explicit catch/history or a local resource`);
+}
+/** One process per opened Square. No replay, pooling, or operation policy. */
+class Connection {
+    nextId = 0;
+    closed = false;
+    closing;
+    pending = new Map();
+    child;
+    exited;
+    constructor(command, args, cwd, env) {
+        this.child = spawn(command, [...args], { cwd, env, shell: false, stdio: 'pipe' });
+        this.exited = new Promise(resolve => this.child.once('close', () => resolve()));
+        // Diagnostic bytes are deliberately not included in errors (they can contain credentials).
+        this.child.stderr.resume();
+        const lines = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
+        let frameBytes = 0;
+        this.child.stdout.on('data', chunk => {
+            for (const byte of chunk) {
+                if (byte === 10)
+                    frameBytes = 0;
+                else if (++frameBytes > STDIO_MAX_FRAME_BYTES) {
+                    this.fail('Backend frame exceeds the protocol limit');
+                    break;
+                }
+            }
+        });
+        lines.on('line', line => {
+            try {
+                const message = JSON.parse(line);
+                if (message.jsonrpc !== '2.0')
+                    throw new Error();
+                if (message.method === 'square/progress') {
+                    const pending = this.pending.get(message.params?.id);
+                    if (pending && message.params?.progress) {
+                        try {
+                            pending.control?.onProgress?.(message.params.progress);
+                        }
+                        catch { /* progress observers cannot corrupt framing */ }
+                    }
+                    return;
+                }
+                if (!Number.isSafeInteger(message.id) || (Object.hasOwn(message, 'result') === Object.hasOwn(message, 'error')))
+                    throw new Error();
+                const pending = this.pending.get(message.id);
+                if (!pending)
+                    throw new Error();
+                this.pending.delete(message.id);
+                pending.dispose();
+                if (message.error)
+                    pending.reject(decodeError(message.error));
+                else
+                    pending.resolve(message.result);
+            }
+            catch {
+                this.fail('Malformed backend protocol response');
+            }
+        });
+        lines.once('close', () => this.fail('Backend stdout ended'));
+        this.child.once('error', () => this.fail('Cannot start configured backend; check command and cwd'));
+        this.child.once('exit', () => this.fail('Backend process exited'));
+        this.child.stdin.on('error', () => this.fail('Backend stdin closed'));
+    }
+    fail(message) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const pending of this.pending.values()) {
+            pending.dispose();
+            const error = new SquareError('unavailable', message);
+            if (pending.method === 'express')
+                Object.assign(error, { operation: { operation: 'express', expressEffect: 'unknown' } });
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.child.stdin.destroy();
+        this.child.kill();
+        const timer = setTimeout(() => this.child.kill('SIGKILL'), 500);
+        timer.unref();
+        void this.exited.then(() => clearTimeout(timer));
+    }
+    request(method, params, control) {
+        if (control?.signal?.aborted)
+            return Promise.reject(control.signal.reason ?? new Error('Operation cancelled'));
+        if (this.closed)
+            return Promise.reject(new SquareError('unavailable', 'Backend connection is closed'));
+        const id = ++this.nextId;
+        let frame;
+        try {
+            frame = JSON.stringify({ jsonrpc: '2.0', id, method, params }, (_key, value) => {
+                if (typeof value === 'number' && !Number.isFinite(value))
+                    throw new Error('Non-finite number');
+                return value;
+            }) + '\n';
+            if (Buffer.byteLength(frame) > STDIO_MAX_FRAME_BYTES)
+                throw new Error('Frame too large');
+        }
+        catch {
+            const error = new SquareError('invalid_args', 'Backend request must be JSON-serializable with finite numbers and fit the protocol frame limit');
+            if (method === 'express')
+                Object.assign(error, { operation: { operation: 'express', expressEffect: 'unsent' } });
+            return Promise.reject(error);
+        }
+        return new Promise((resolve, reject) => {
+            const abort = () => {
+                // Wait for the response: server cleanup (including catch lease release) must finish first.
+                if (!this.closed)
+                    this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: '$/cancelRequest', params: { id } }) + '\n');
+            };
+            this.pending.set(id, { resolve, reject, method, control, dispose: () => control?.signal?.removeEventListener('abort', abort) });
+            control?.signal?.addEventListener('abort', abort, { once: true });
+            this.child.stdin.write(frame);
+        });
+    }
+    close() {
+        return this.closing ??= (async () => {
+            const timer = setTimeout(() => this.fail('Backend close timed out'), 1000);
+            try {
+                if (!this.closed)
+                    await this.request('square/close', {});
+            }
+            catch { /* disconnect already rejects outstanding work */ }
+            finally {
+                clearTimeout(timer);
+                this.fail('Backend connection closed');
+                await this.exited;
+            }
+        })();
+    }
+}
+class StdioSquare {
+    location;
+    connection;
+    handle;
+    constructor(location, connection, handle) {
+        this.location = location;
+        this.connection = connection;
+        this.handle = handle;
+    }
+    call(method, args, control, participant) {
+        return this.connection.request(method, { handle: this.handle, args, ...(participant === undefined ? {} : { participant }) }, control);
+    }
+    participantHandle(name) {
+        return {
+            name,
+            express: ((bodyOrInput, optionsOrControl, control) => {
+                if (typeof bodyOrInput === 'object' && bodyOrInput !== null)
+                    return this.call('express', [bodyOrInput, undefined], optionsOrControl, name);
+                return this.call('express', [bodyOrInput, optionsOrControl], control, name);
+            }),
+            catch: (options, control) => this.call('catch', [options], control, name),
+            listen: (target, options, control) => this.call('listen', [target, options], control, name),
+            ignore: (target, options, control) => this.call('ignore', [target, options], control, name),
+            unlisten: (target, options, control) => this.call('unlisten', [target, options], control, name),
+            listening: (options, control) => this.call('listening', [options], control, name),
+            hold: (reason, options, control) => this.call('hold', [reason, options], control, name),
+            resume: (options, control) => this.call('resume', [options], control, name),
+            done: (body, options, control) => this.call('done', [body, options], control, name),
+            history: (query, control) => this.history(query, control),
+        };
+    }
+    async participant(name) { return this.participantHandle(await this.call('participant', [name])); }
+    async join(...[name, options, control]) {
+        requireJoinName(name);
+        const result = await this.call('join', [name, options], control);
+        return { ...result, participant: this.participantHandle(result.participant) };
+    }
+    history(...[query, control]) { return this.call('history', [query], control); }
+    status(...[options, control]) { return this.call('status', [options], control); }
+    participants(...[options, control]) { return this.call('participants', [options], control); }
+    recovery(...[name, control]) { return this.call('recovery', [name], control); }
+    snapshot() { return Promise.reject(new SquareError('invalid_args', 'stdio does not support function-valued snapshot; use status/participants/history')); }
+    stream() { unsupported('stream'); }
+    recognize() { return Promise.reject(new SquareError('invalid_args', 'stdio does not support host recognition; select a participant explicitly')); }
+    implicitJoin() { unsupported('host implicit join'); }
+    endOwnedSession() { unsupported('host session cleanup'); }
+    cancelDeliveries() { unsupported('host delivery cancellation'); }
+    close() { return this.connection.close(); }
+}
+export async function openStdioSquare(location, selected, input, backends, build, control) {
+    if (input.clock || input.wakeTransport)
+        unsupported('client clock or wakeTransport injection');
+    if (control?.signal?.aborted)
+        throw control.signal.reason ?? new Error('Operation cancelled');
+    const backend = Object.hasOwn(backends, selected.backend) ? backends[selected.backend] : undefined;
+    if (!backend)
+        throw new SquareError('invalid_args', `Backend ${selected.backend} is not configured; set backends or SQUARE_BACKENDS_CONFIG`);
+    const cwd = input.cwd ?? process.cwd();
+    const command = backend.command.includes('/') || backend.command.includes('\\') ? path.resolve(cwd, backend.command) : backend.command;
+    const connection = new Connection(command, backend.args ?? [], path.resolve(cwd, backend.cwd ?? '.'), { ...(input.env ?? process.env), ...backend.env });
+    try {
+        const result = await connection.request('square/open', { version: STDIO_PROTOCOL_VERSION, key: selected.key, location,
+            identity: wireIdentity(input.env ?? process.env), body: input.body, participant: input.participant, build }, control);
+        if (result.version !== STDIO_PROTOCOL_VERSION || typeof result.handle !== 'string')
+            throw new SquareError('unavailable', 'Backend protocol version mismatch');
+        return new StdioSquare(location, connection, result.handle);
+    }
+    catch (error) {
+        await connection.close();
+        throw error;
+    }
+}

package/dist/square-tools.js

@@ -2,7 +2,7 @@ import { z } from 'zod/v4';
 import { isSquareError } from './model.js';
 import { CATCH_DEFAULT_LIMIT } from './square-api.js';
 import { renderCatchOutcome, renderExpression, renderFailureLines, renderHistoryResult, renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, renderParticipantsResult, renderStatusResult, } from './operation-presentation.js';
-const location = z.string().optional().describe('Path to the .square artifact, relative to the current working directory. Defaults to the configured square.');
+const location = z.string().optional().describe('Local .square artifact path or configured backend URI (stdio://name/key). Relative paths use the current working directory. Defaults to the configured square.');
 const participant = z.string().optional().describe('Participant name. Defaults to the configured participant or the current session’s unambiguous participant.');
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
@@ -14,11 +14,38 @@ function observation(control) {
 function rendering(render) {
     return (result, args) => render(result, args);
 }
+/**
+ * Tool receipts are the one machine surface without activity metadata: a receipt copy drops every
+ * property named `metadata` while domain activities keep theirs for SDK, CLI, stdio and stream readers.
+ */
+function withoutActivityMetadata(value) {
+    if (Array.isArray(value))
+        return value.map(withoutActivityMetadata);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return value;
+    return Object.fromEntries(Object.entries(value).filter(([key]) => key !== 'metadata')
+        .map(([key, item]) => [key, withoutActivityMetadata(item)]));
+}
+/**
+ * Human text renders from the unfiltered receipt, so metadata-only says keep the placeholder the
+ * CLI prints and every other sentence stays identical. Machines only ever receive the filtered copy.
+ */
+const renderingReceipts = new WeakMap();
+function renderingReceipt(receipt) {
+    return (renderingReceipts.get(receipt) ?? receipt);
+}
 function tool(name, description, shape, run, render) {
     const inputSchema = z.object({ ...shape, location }).strict();
-    return { name, description, inputSchema, render, run: (square, args, control) => {
+    return { name, description, inputSchema, render: (receipt, args) => render(renderingReceipt(receipt), args),
+        run: async (square, args, control) => {
             const { location: _location, ...operationArgs } = inputSchema.parse(args);
-            return run(square, operationArgs, control);
+            const receipt = await run(square, operationArgs, control);
+            const filtered = withoutActivityMetadata(receipt);
+            renderingReceipts.set(filtered, receipt);
+            return filtered;
         } };
 }
 export const SQUARE_TOOL_INSTRUCTIONS = 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.';

package/dist/stdio-server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+/** Serve the existing resource API. This adapter contains no activity policy. */
+export declare function runSquareStdioServer(root: string): Promise<void>;

package/dist/stdio-server.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { pathToFileURL } from 'node:url';
+import { SqliteSquare } from './sqlite-square.js';
+import { SquareError, validateBody } from './model.js';
+import { canonicalPath } from './canonical-path.js';
+import { STDIO_PROTOCOL_VERSION, STDIO_MAX_FRAME_BYTES, encodeError, identityVariables } from './square-stdio.js';
+import { parseSquareLocation } from './square-location.js';
+/** Serve the existing resource API. This adapter contains no activity policy. */
+export async function runSquareStdioServer(root) {
+    await fs.mkdir(root, { recursive: true });
+    root = await canonicalPath(root);
+    const baseEnv = { ...process.env };
+    let square;
+    let location;
+    let opening = false, closing = false;
+    const running = new Map();
+    const write = (message) => { if (!process.stdout.destroyed)
+        process.stdout.write(JSON.stringify(message) + '\n'); };
+    const response = (id, result) => write({ jsonrpc: '2.0', id, result });
+    const fail = (id, error) => write({ jsonrpc: '2.0', id, error: encodeError(error) });
+    const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    let shutdown;
+    const close = () => shutdown ??= (async () => {
+        closing = true;
+        for (const request of running.values())
+            request.controller.abort();
+        await Promise.allSettled([...running.values()].map(request => request.work));
+        await square?.close();
+        lines.close();
+        process.stdin.pause();
+    })();
+    const fatal = () => { void close().finally(() => { process.exitCode = 1; }); };
+    let frameBytes = 0;
+    process.stdin.on('data', chunk => {
+        for (const byte of Buffer.from(chunk)) {
+            if (byte === 10)
+                frameBytes = 0;
+            else if (++frameBytes > STDIO_MAX_FRAME_BYTES) {
+                fatal();
+                break;
+            }
+        }
+    });
+    process.stdout.on('error', fatal);
+    process.once('SIGTERM', fatal);
+    process.once('SIGINT', fatal);
+    lines.on('close', () => { if (!closing)
+        void close(); });
+    async function invoke(method, params, control) {
+        if (method === 'square/open') {
+            if (square || opening)
+                throw new SquareError('invalid_args', 'One logical open is allowed per connection');
+            opening = true;
+            try {
+                if (params.version !== STDIO_PROTOCOL_VERSION)
+                    throw new SquareError('invalid_args', 'Unsupported Square stdio protocol version');
+                const parsed = parseSquareLocation(params.location);
+                if (parsed.kind !== 'stdio' || parsed.key !== params.key)
+                    throw new SquareError('invalid_args', 'Open requires a matching stdio location and key');
+                const target = path.join(root, `${parsed.key}.square`);
+                const canonical = await canonicalPath(target);
+                if (path.dirname(canonical) !== root)
+                    throw new SquareError('invalid_args', 'Square key escapes the configured backend root');
+                const env = { ...baseEnv };
+                for (const key of identityVariables) {
+                    const value = params.identity?.[key];
+                    if (value !== undefined && typeof value !== 'string')
+                        throw new SquareError('invalid_args', 'Invalid operation identity');
+                    env[key] = value ?? '';
+                }
+                const input = { path: target, env, body: params.body, participant: params.participant };
+                if (params.body !== undefined)
+                    validateBody(params.body);
+                square = params.build === undefined ? await SqliteSquare.at(input, control, false)
+                    : await SqliteSquare.build({ ...params.build, ...input }, control, false);
+                location = parsed.uri;
+                return { version: STDIO_PROTOCOL_VERSION, handle: 'square' };
+            }
+            finally {
+                opening = false;
+            }
+        }
+        if (!square || params.handle !== 'square')
+            throw new SquareError('invalid_args', 'Open a logical square first');
+        if (!Array.isArray(params.args))
+            throw new SquareError('invalid_args', 'Operation args must be an array');
+        // JSON null represents omitted optional arguments, never the meaningful history limit:null inside an options object.
+        const args = params.args.map((arg) => arg === null ? undefined : arg);
+        let result;
+        switch (method) {
+            case 'participant': return (await square.participant(args[0])).name;
+            case 'join': {
+                const joined = await square.join(args[0], args[1], control);
+                result = { ...joined, participant: joined.participant.name };
+                break;
+            }
+            case 'history':
+                result = await square.history(args[0], control);
+                break;
+            case 'status':
+                result = await square.status(args[0], control);
+                break;
+            case 'participants':
+                result = await square.participants(args[0], control);
+                break;
+            case 'recovery':
+                result = await square.recovery(args[0], control);
+                break;
+            default: {
+                if (typeof params.participant !== 'string')
+                    throw new SquareError('invalid_args', 'Participant operation requires a name');
+                const participant = await square.participant(params.participant);
+                switch (method) {
+                    case 'express':
+                        result = await participant.express(args[0], args[1], control);
+                        break;
+                    case 'catch':
+                        result = await participant.catch(args[0], control);
+                        break;
+                    case 'listen':
+                        result = await participant.listen(args[0], args[1], control);
+                        break;
+                    case 'ignore':
+                        result = await participant.ignore(args[0], args[1], control);
+                        break;
+                    case 'unlisten':
+                        result = await participant.unlisten(args[0], args[1], control);
+                        break;
+                    case 'listening':
+                        result = await participant.listening(args[0], control);
+                        break;
+                    case 'hold':
+                        result = await participant.hold(args[0], args[1], control);
+                        break;
+                    case 'resume':
+                        result = await participant.resume(args[0], control);
+                        break;
+                    case 'done':
+                        result = await participant.done(args[0], args[1], control);
+                        break;
+                    default: throw new SquareError('invalid_args', 'Unsupported stdio operation');
+                }
+            }
+        }
+        if (result?.observation)
+            result = { ...result, observation: { ...result.observation, location, automaticDeliveryAvailable: false } };
+        return result;
+    }
+    lines.on('line', line => {
+        if (closing)
+            return;
+        let message;
+        try {
+            message = JSON.parse(line);
+            if (message.jsonrpc !== '2.0' || typeof message.method !== 'string' || !message.params || typeof message.params !== 'object')
+                throw new Error();
+            if (message.method === '$/cancelRequest') {
+                running.get(message.params.id)?.controller.abort();
+                return;
+            }
+            if (!Number.isSafeInteger(message.id) || running.has(message.id))
+                throw new Error();
+        }
+        catch {
+            fatal();
+            return;
+        }
+        if (message.method === 'square/close') {
+            void close().then(() => { response(message.id, null); process.stdout.end(); });
+            return;
+        }
+        const controller = new AbortController();
+        // Start on a microtask so the request is tracked before progress/cleanup can run.
+        const work = Promise.resolve().then(() => invoke(message.method, message.params, {
+            signal: controller.signal,
+            onProgress: progress => write({ jsonrpc: '2.0', method: 'square/progress', params: { id: message.id, progress } }),
+        })).then(result => response(message.id, result), error => fail(message.id, error)).finally(() => { running.delete(message.id); });
+        running.set(message.id, { controller, work });
+    });
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    if (process.argv.length !== 4 || process.argv[2] !== '--root') {
+        process.stderr.write('usage: node dist/stdio-server.js --root <backend-artifact-directory>\n');
+        process.exitCode = 2;
+    }
+    else {
+        await runSquareStdioServer(path.resolve(process.argv[3]));
+    }
+}

package/dist/stream.d.ts

@@ -1,3 +1,4 @@
-import type { OpenOptions, OperationControl, StreamOptions, StreamRecord } from './square-facade.js';
+import type { SquareArtifactPort } from './ports.js';
+import type { OperationControl, StreamOptions, StreamRecord } from './square-facade.js';
 /** Pull-based observation; return interrupts an outstanding pull before awaiting its cleanup. */
-export declare function streamSquare(squarePath: string, options?: StreamOptions, control?: OperationControl, openOptions?: OpenOptions): AsyncIterable<StreamRecord>;
+export declare function streamSquare(squarePath: string, options?: StreamOptions, control?: OperationControl, borrowed?: SquareArtifactPort): AsyncIterable<StreamRecord>;

package/dist/stream.js

@@ -1,15 +1,13 @@
 import fs from 'node:fs/promises';
 import { SquareError } from './model.js';
-import { observeSquareRevision } from './artifact.js';
-import { openSquare, closeOpenSquare } from './open-square.js';
+import { createArtifactPort, observeSquareRevision } from './artifact.js';
 import { streamProjection, streamTailProjection } from './views.js';
 /** Pull-based observation; return interrupts an outstanding pull before awaiting its cleanup. */
-export function streamSquare(squarePath, options = {}, control, openOptions = {}) {
+export function streamSquare(squarePath, options = {}, control, borrowed) {
     return {
         [Symbol.asyncIterator]() {
             const disposal = new AbortController();
             const signal = control?.signal === undefined ? disposal.signal : AbortSignal.any([control.signal, disposal.signal]);
-            const iterationControl = { ...control, signal };
             const records = observe();
             return {
                 next: () => records.next(),
@@ -43,19 +41,20 @@ export function streamSquare(squarePath, options = {}, control, openOptions = {}
                             let projection;
                             try {
                                 baseline = await observer.read(signal);
-                                const square = await openSquare(squarePath, { ...openOptions, env: openOptions.env ?? {}, signal }, iterationControl);
+                                const artifact = borrowed ?? createArtifactPort(squarePath, undefined, signal);
                                 try {
-                                    projection = initial === undefined
-                                        ? await streamProjection(square, cursor, options.recipient, iterationControl)
-                                        : await streamTailProjection(square, initial.last, options.recipient, iterationControl);
+                                    projection = (await artifact.read(facts => initial === undefined
+                                        ? streamProjection(facts, cursor, options.recipient)
+                                        : streamTailProjection(facts, initial.last, options.recipient), signal)).value;
                                 }
                                 finally {
-                                    await closeOpenSquare(square);
+                                    if (borrowed === undefined)
+                                        await artifact.close();
                                 }
                             }
                             catch (error) {
                                 signal.throwIfAborted();
-                                if (error instanceof SquareError && error.code === 'invalid_args')
+                                if (borrowed !== undefined || error instanceof SquareError && error.code === 'invalid_args')
                                     throw error;
                                 // Repair/replacement is a hint, not a reason to scan history on a timer.
                                 await observer.hinted(generation, Infinity, signal);

package/dist/views.d.ts

@@ -1,8 +1,7 @@
 import { type ActivityId } from './square-core.js';
 import { type StoredAct } from './model.js';
-import type { OpenSquare } from './open-square.js';
 import type { ActivityFilter, SquareRead } from './ports.js';
-import type { Activity, ArchiveRecord, HistoryQuery, HistoryContinuation, OperationControl, ParticipantsResult, SquareSnapshot, EntryPresentation, ListPresentation, StatusResult, SquareObservation, CatchPresence, StreamProjection } from './square-facade.js';
+import type { Activity, ArchiveRecord, HistoryQuery, HistoryContinuation, ParticipantsResult, SquareSnapshot, EntryPresentation, ListPresentation, StatusResult, SquareObservation, CatchPresence, StreamProjection } from './square-facade.js';
 export type { EntryPresentation, ListPresentation, CatchPresence, StreamProjection } from './square-facade.js';
 export declare const HISTORY_DEFAULT_LIMIT = 10;
 export declare const HISTORY_MAX_LIMIT = 100;
@@ -18,12 +17,8 @@ export declare function selectHistory(facts: SquareRead, query: HistoryQuery, li
     totalMatches: number;
 };
 export declare function publicActivities(activities: readonly ArchiveRecord[]): Activity[];
-export declare function resolveParticipant(square: OpenSquare, name: string, control?: OperationControl): Promise<{
-    name: string;
-}>;
-export declare function currentParticipant(square: OpenSquare, name: string, control?: OperationControl): Promise<string | undefined>;
-export declare function snapshot(square: OpenSquare, control?: OperationControl): Promise<SquareSnapshot>;
-export declare function recoveryObservation(square: OpenSquare, name: string, control?: OperationControl): Promise<{
+export declare function snapshot(facts: SquareRead, now: number): SquareSnapshot;
+export declare function recoveryObservation(facts: SquareRead, name: string, now: number): {
     ownActivityCount: number;
     hardCap: import("./model.js").HardCap;
     holdReason?: string | undefined;
@@ -32,12 +27,12 @@ export declare function recoveryObservation(square: OpenSquare, name: string, co
     activitySummaries: import("./square-facade.js").UnreadActivitySummary[];
     standingCount: number;
     held: boolean;
-}>;
-export declare function entryPresentation(square: OpenSquare, name: string, lastN?: number | null, control?: OperationControl): Promise<EntryPresentation>;
+};
+export declare function entryPresentation(facts: SquareRead, name: string, lastN?: number | null): EntryPresentation;
 type ParticipantQueryContext = Pick<SquareObservation, 'location' | 'now' | 'automaticDeliveryAvailable'>;
 export declare function queryParticipants(facts: SquareRead, context: ParticipantQueryContext, observe?: boolean): ParticipantsResult;
-export declare function listPresentation(square: OpenSquare, control?: OperationControl): Promise<ListPresentation>;
+export declare function listPresentation(facts: SquareRead): ListPresentation;
 export declare function queryStatus(facts: SquareRead, context: ParticipantQueryContext, viewer?: string, observe?: boolean): StatusResult;
-export declare function catchPresence(square: OpenSquare, control?: OperationControl): Promise<CatchPresence>;
-export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string, control?: OperationControl): Promise<StreamProjection>;
-export declare function streamTailProjection(square: OpenSquare, last?: number, recipient?: string, control?: OperationControl): Promise<StreamProjection>;
+export declare function catchPresence(facts: SquareRead, now: number): CatchPresence;
+export declare function streamProjection(facts: SquareRead, cursor: number, recipient?: string): StreamProjection;
+export declare function streamTailProjection(facts: SquareRead, last?: number, recipient?: string): StreamProjection;