@astrosheep/square 0.3.70 → 0.3.71

package/dist/square-file-adapter.js

@@ -1,85 +0,0 @@
-export { observeSquareRevision as observeSquareChanges } from './artifact.js';
-import { hostLedgerRoot } from './host-ledger-root.js';
-import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, createFileCell, createMemoryCell, } from './square-storage.js';
-import { InternalSquareError, SquareError, } from './model.js';
-import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-/** File-owned artifact creation for the CLI and path-backed public facade. */
-export async function createSquare(squarePath, options, snippet) {
-    const state = createSquareState(options, snippet);
-    if (options.force) {
-        await writeSquareSnapshot(squarePath, state);
-        return;
-    }
-    if (!await createSquareSnapshot(squarePath, state)) {
-        throw new InternalSquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
-    }
-}
-function validateBuildOptions(options) {
-    if (options.hardCap !== undefined && options.hardCap !== null
-        && (!Number.isSafeInteger(options.hardCap) || options.hardCap < 1)) {
-        throw new SquareError('invalid_args', 'hardCap must be a positive integer or null');
-    }
-    if (options.throttlePerMinute !== undefined
-        && (!Number.isSafeInteger(options.throttlePerMinute) || options.throttlePerMinute < 1)) {
-        throw new SquareError('invalid_args', 'throttlePerMinute must be a positive integer');
-    }
-}
-export async function openSquare(squarePath, options = {}, control) {
-    const env = options.env ?? process.env;
-    const ledgerRoot = hostLedgerRoot(env);
-    const artifact = openSquareArtifact(squarePath, options.signal);
-    try {
-        await artifact.read(control?.signal);
-        return {
-            artifact,
-            clock: options.clock ?? Date.now,
-            location: squarePath,
-            env,
-            hostLedger: options.hostLedger ?? createHostLedgerPort({
-                rootPath: ledgerRoot,
-            }),
-            wakeTransport: options.wakeTransport,
-        };
-    }
-    catch (error) {
-        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 probeSquare(squarePath) {
-    const state = await probeSquareFile(squarePath);
-    return state === undefined ? undefined : { artifact: createMemoryCell(state), clock: Date.now, location: squarePath, hostLedger: createHostLedgerPort({ rootPath: hostLedgerRoot(process.env) }) };
-}
-export async function buildSquare(squarePath, options) {
-    validateBuildOptions(options);
-    try {
-        await createSquare(squarePath, {
-            force: false,
-            hardCap: options.hardCap ?? null,
-            ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
-        }, options.markdown);
-    }
-    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);
-}
-export function buildMemorySquare(options) {
-    validateBuildOptions(options);
-    const squareState = createSquareState({
-        force: false,
-        hardCap: options.hardCap ?? null,
-        ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
-    }, options.markdown);
-    return { artifact: createMemoryCell(squareState), clock: options.clock ?? Date.now, location: 'memory', hostLedger: options.hostLedger, wakeTransport: options.wakeTransport };
-}
-/** A projection reads and validates its snapshot once; no preliminary duplicate read. */
-export function openSquareArtifact(squarePath, signal) {
-    return createFileCell(squarePath, signal);
-}

package/dist/square-state.d.ts

@@ -1,6 +0,0 @@
-import { type BuildOptions, type HardCap, type SquareRuntimeState, type SquareState } from './model.js';
-export declare function validateSquareState(value: unknown): SquareState;
-export declare function emptyRuntimeState(nextActIndex?: number): SquareRuntimeState;
-export declare function createSquareState(options: BuildOptions & {
-    hardCap: HardCap;
-}, snippet: string): SquareState;

package/dist/square-state.js

@@ -1,138 +0,0 @@
-import fs from 'node:fs';
-import { isWakeRouteKind, SquareError, } from './model.js';
-import { parseActivityId } from './square-core.js';
-const guideNames = ['participant', 'architect', 'brainstorm'];
-const guideContents = new Map(await Promise.all(guideNames.map(async (name) => [name, (await fs.promises.readFile(new URL(`../guides/${name}.md`, import.meta.url), 'utf8')).trim()])));
-function invalidArtifact(detail) {
-    return new SquareError('invalid_args', `Invalid square artifact: ${detail}`);
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function hasExactKeys(value, required, optional = []) {
-    const allowed = new Set([...required, ...optional]);
-    return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => allowed.has(key));
-}
-function isFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-function isNonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
-}
-function isNonblankString(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string');
-}
-function validateWatchLease(value) {
-    if (!isObject(value) || !hasExactKeys(value, ['leaseId', 'heartbeatAt', 'expiresAt'], ['filter'])
-        || !isNonblankString(value.leaseId) || !isFiniteNumber(value.heartbeatAt)
-        || !isFiniteNumber(value.expiresAt) || value.expiresAt < value.heartbeatAt)
-        return false;
-    if (value.filter === undefined)
-        return true;
-    return isObject(value.filter) && hasExactKeys(value.filter, [], ['participants', 'mention'])
-        && (value.filter.participants === undefined || isStringArray(value.filter.participants))
-        && (value.filter.mention === undefined || typeof value.filter.mention === 'string');
-}
-function validateRecord(value, item) {
-    return isObject(value) && Object.entries(value).every(([key, candidate]) => key.length > 0 && item(candidate));
-}
-function validateRuntime(value) {
-    return isObject(value) && hasExactKeys(value, ['nextActIndex', 'observations', 'leases'])
-        && isNonNegativeInteger(value.nextActIndex)
-        && validateRecord(value.observations, (candidate) => isObject(candidate)
-            && Object.entries(candidate).every(([id, observation]) => parseActivityId(id) !== undefined && isObject(observation) && hasExactKeys(observation, ['state', 'at']) && observation.state === 'seen' && isFiniteNumber(observation.at)))
-        && validateRecord(value.leases, validateWatchLease);
-}
-function validateAssignedRuntimeReferences(runtime) {
-    for (const observations of Object.values(runtime.observations)) {
-        for (const id of Object.keys(observations)) {
-            const index = parseActivityId(id);
-            if (index === undefined)
-                return 'malformed';
-            if (index >= runtime.nextActIndex)
-                return 'future';
-        }
-    }
-    return 'ok';
-}
-function validateActor(value, required) {
-    return required ? isNonblankString(value) : value === undefined || isNonblankString(value);
-}
-function validateStoredAct(value) {
-    if (!isObject(value) || typeof value.kind !== 'string' || !isNonNegativeInteger(value.index) || !isFiniteNumber(value.at))
-        return false;
-    switch (value.kind) {
-        case 'join': return hasExactKeys(value, ['kind', 'actor', 'at', 'index']) && validateActor(value.actor, true);
-        case 'done': return hasExactKeys(value, ['kind', 'actor', 'at', 'index'], ['body']) && validateActor(value.actor, true) && (value.body === undefined || typeof value.body === 'string');
-        case 'say': return hasExactKeys(value, ['kind', 'actor', 'at', 'body', 'index'], ['mentions', 'reach', 'reply'])
-            && validateActor(value.actor, true) && typeof value.body === 'string'
-            && (value.mentions === undefined || isStringArray(value.mentions)) && (value.reach === undefined || value.reach === 'bell')
-            && (value.reply === undefined || isNonNegativeInteger(value.reply));
-        case 'hold': return hasExactKeys(value, ['kind', 'at', 'index'], ['actor', 'body']) && validateActor(value.actor, false) && (value.body === undefined || typeof value.body === 'string');
-        case 'resume': return hasExactKeys(value, ['kind', 'at', 'index'], ['actor']) && validateActor(value.actor, false);
-        case 'read': return hasExactKeys(value, ['kind', 'actor', 'at', 'through', 'index']) && validateActor(value.actor, true) && isNonNegativeInteger(value.through);
-        case 'listen':
-        case 'ignore': return hasExactKeys(value, ['kind', 'actor', 'target', 'at', 'index']) && validateActor(value.actor, true) && validateActor(value.target, true);
-        default: return false;
-    }
-}
-function validateActs(value) {
-    if (!Array.isArray(value) || !value.every(validateStoredAct))
-        return false;
-    let previous = -1;
-    for (const act of value) {
-        if (act.index <= previous || (act.kind === 'say' && act.reply !== undefined && act.reply >= act.index))
-            return false;
-        previous = act.index;
-    }
-    return true;
-}
-export function validateSquareState(value) {
-    if (!isObject(value) || !hasExactKeys(value, ['hardCap', 'preamble', 'warmup', 'acts', 'runtime'], ['throttlePerMinute', 'routes'])
-        || !(value.hardCap === null || (Number.isSafeInteger(value.hardCap) && value.hardCap > 0))
-        || (value.throttlePerMinute !== undefined && (!Number.isSafeInteger(value.throttlePerMinute) || value.throttlePerMinute <= 0))
-        || !isStringArray(value.preamble) || !isStringArray(value.warmup) || !validateActs(value.acts)
-        || (value.routes !== undefined && (!Array.isArray(value.routes) || !value.routes.every((route) => isObject(route) && isWakeRouteKind(route.kind)
-            && typeof route.location === 'string' && typeof route.participant === 'string' && typeof route.sessionId === 'string'
-            && typeof route.channel === 'string' && isObject(route.address) && Object.values(route.address).every((item) => typeof item === 'string')
-            && typeof route.updatedAt === 'number')))
-        || !validateRuntime(value.runtime))
-        throw invalidArtifact('snapshot schema is malformed.');
-    const historyBoundary = value.acts.at(-1)?.index ?? -1;
-    if (value.runtime.nextActIndex <= historyBoundary)
-        throw invalidArtifact('nextActIndex is behind the activity history.');
-    const references = validateAssignedRuntimeReferences(value.runtime);
-    if (references === 'malformed')
-        throw invalidArtifact('snapshot schema is malformed.');
-    if (references === 'future')
-        throw invalidArtifact('runtime references an unassigned activity index.');
-    return value;
-}
-export function emptyRuntimeState(nextActIndex = 0) {
-    return { nextActIndex, observations: {}, leases: {} };
-}
-function normalizedLines(value) {
-    const normalized = value.replace(/\r\n/g, '\n').trim();
-    return normalized === '' ? [] : normalized.split('\n');
-}
-function readGuide(name) {
-    const guide = guideContents.get(name);
-    if (guide === undefined)
-        throw new SquareError('invalid_args', `Unknown square guide: ${name}`);
-    return guide;
-}
-export function createSquareState(options, snippet) {
-    const guides = [readGuide('participant')];
-    if (options.template !== undefined)
-        guides.push(readGuide(options.template));
-    return {
-        hardCap: options.hardCap,
-        ...(options.throttlePerMinute === undefined ? {} : { throttlePerMinute: options.throttlePerMinute }),
-        preamble: normalizedLines(snippet),
-        warmup: normalizedLines(guides.join('\n\n')),
-        acts: [], routes: [], runtime: emptyRuntimeState(),
-    };
-}

package/dist/square-storage.d.ts

@@ -1,14 +0,0 @@
-import { createSquareState, diagnoseSquareFile as diagnoseArtifactFile } from './artifact.js';
-import type { SquareState } from './model.js';
-import type { SquareArtifactPort } from './ports.js';
-export { createSquareState };
-export declare function probeSquareFile(squarePath: string): Promise<SquareState | undefined>;
-export declare function diagnoseSquareFile(squarePath: string): ReturnType<typeof diagnoseArtifactFile>;
-/** Test-helper snapshot replacement backed by one SQLite artifact. */
-export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): Promise<void>;
-/** Race-safe non-force creation for the file adapter. */
-export declare function createSquareSnapshot(squarePath: string, squareState: SquareState): Promise<boolean>;
-/** In-process artifact for fast behavior tests and embedded consumers. */
-export declare function createMemoryCell(initial: SquareState): SquareArtifactPort;
-/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
-export declare function createFileCell(squarePath: string, externalSignal?: AbortSignal): SquareArtifactPort;

package/dist/square-storage.js

@@ -1,188 +0,0 @@
-import { isDeepStrictEqual } from 'node:util';
-import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, probeSquare, observeSquareRevision, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
-import { canonicalPath } from './canonical-path.js';
-export { createSquareState };
-export async function probeSquareFile(squarePath) {
-    if (!squarePath.endsWith('.square'))
-        return undefined;
-    return probeSquare(await canonicalPath(squarePath));
-}
-export async function diagnoseSquareFile(squarePath) {
-    return diagnoseArtifactFile(await canonicalPath(squarePath));
-}
-/** Test-helper snapshot replacement backed by one SQLite artifact. */
-export async function writeSquareSnapshot(squarePath, squareState) {
-    await writeSquareFile(await canonicalPath(squarePath), squareState);
-}
-/** Race-safe non-force creation for the file adapter. */
-export async function createSquareSnapshot(squarePath, squareState) {
-    return createSquareFile(await canonicalPath(squarePath), squareState);
-}
-function cloneState(squareState) {
-    return structuredClone(squareState);
-}
-function assertCellOpen(closed) {
-    if (closed)
-        throw new Error('Square artifact is closed');
-}
-function isThenable(value) {
-    return (typeof value === 'object' || typeof value === 'function') && value !== null
-        && typeof value.then === 'function';
-}
-function discardThenable(value) {
-    void Promise.resolve(value).catch(() => undefined);
-}
-/** In-process artifact for fast behavior tests and embedded consumers. */
-export function createMemoryCell(initial) {
-    let state = cloneState(initial);
-    let version = 0;
-    let closed = false;
-    let tail = Promise.resolve();
-    const waiters = new Set();
-    function publish() {
-        for (const waiter of [...waiters]) {
-            if (version <= waiter.since)
-                continue;
-            clearTimeout(waiter.timer);
-            waiters.delete(waiter);
-            waiter.signal?.removeEventListener("abort", waiter.onAbort);
-            waiter.resolve(true);
-        }
-    }
-    return {
-        transact(fn, signal) {
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                throw signal.reason ?? new Error('Square artifact operation aborted');
-            const operation = tail.then(() => {
-                assertCellOpen(closed);
-                if (signal?.aborted)
-                    throw signal.reason ?? new Error('Square artifact operation aborted');
-                const current = cloneState(state);
-                const outcome = fn(current, version);
-                if (isThenable(outcome)) {
-                    discardThenable(outcome);
-                    throw new TypeError('Square artifact transitions must be synchronous.');
-                }
-                if (typeof outcome !== 'object' || outcome === null || !Object.hasOwn(outcome, 'result')) {
-                    throw new TypeError('Square artifact transition must return { state?, result }.');
-                }
-                if (outcome.state !== undefined && !isDeepStrictEqual(outcome.state, state)) {
-                    state = cloneState(outcome.state);
-                    version += 1;
-                    publish();
-                }
-                return outcome.result;
-            });
-            tail = operation.then(() => undefined, () => undefined);
-            return operation;
-        },
-        async read(signal) {
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                throw signal.reason ?? new Error('Square artifact operation aborted');
-            await tail;
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                throw signal.reason ?? new Error('Square artifact operation aborted');
-            return { state: cloneState(state), version };
-        },
-        changed(sinceVersion, timeoutMs, signal) {
-            assertCellOpen(closed);
-            if (signal?.aborted)
-                return Promise.reject(signal.reason ?? new Error("Square artifact operation aborted"));
-            if (version > sinceVersion)
-                return Promise.resolve(true);
-            if (timeoutMs <= 0)
-                return Promise.resolve(false);
-            return new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(signal.reason ?? new Error("Square artifact operation aborted"));
-                    return;
-                }
-                const abort = () => { waiters.delete(waiter); clearTimeout(waiter.timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("Square artifact operation aborted")); };
-                const waiter = {
-                    since: sinceVersion,
-                    resolve,
-                    timer: setTimeout(() => { waiters.delete(waiter); signal?.removeEventListener("abort", abort); resolve(false); }, timeoutMs),
-                    onAbort: abort,
-                    signal,
-                };
-                waiters.add(waiter);
-                signal?.addEventListener("abort", abort, { once: true });
-            });
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            await tail;
-            for (const waiter of [...waiters]) {
-                clearTimeout(waiter.timer);
-                waiters.delete(waiter);
-                waiter.signal?.removeEventListener("abort", waiter.onAbort);
-                waiter.resolve(false);
-            }
-        },
-    };
-}
-/** SQLite-backed artifact. Revisions are read from the authoritative database, not file metadata. */
-export function createFileCell(squarePath, externalSignal) {
-    let closed = false;
-    let storage;
-    let tail = Promise.resolve();
-    const cancel = new AbortController();
-    function storagePath() {
-        storage ??= canonicalPath(squarePath);
-        return storage;
-    }
-    /** Close wins over every operation; a per-call deadline bounds busy retries alongside it. */
-    function operationSignal(signal) {
-        if (signal === undefined && externalSignal === undefined)
-            return cancel.signal;
-        return AbortSignal.any([cancel.signal, ...(externalSignal === undefined ? [] : [externalSignal]), ...(signal === undefined ? [] : [signal])]);
-    }
-    return {
-        transact(fn, signal) {
-            assertCellOpen(closed);
-            const opSignal = operationSignal(signal);
-            const operation = tail.then(async () => {
-                assertCellOpen(closed);
-                const result = await transactSquareSnapshot(await storagePath(), fn, opSignal);
-                return result.result;
-            });
-            tail = operation.then(() => undefined, () => undefined);
-            return operation;
-        },
-        async read(signal) {
-            assertCellOpen(closed);
-            await tail;
-            assertCellOpen(closed);
-            const snapshot = await readSquareSnapshot(await storagePath(), operationSignal(signal));
-            return { state: cloneState(snapshot.state), version: snapshot.revision };
-        },
-        async changed(sinceVersion, timeoutMs, signal) {
-            assertCellOpen(closed);
-            const deadline = Date.now() + Math.max(0, timeoutMs);
-            const observer = await observeSquareRevision(await storagePath());
-            try {
-                return await observer.changed(sinceVersion, Math.max(0, deadline - Date.now()), operationSignal(signal));
-            }
-            catch (error) {
-                if (closed || cancel.signal.aborted)
-                    return false;
-                throw error;
-            }
-            finally {
-                observer.close();
-            }
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            cancel.abort(new Error('Square artifact is closed'));
-            await tail;
-        },
-    };
-}

package/dist/square-wiring.d.ts

@@ -1,33 +0,0 @@
-import type { Activity, ExpressResult, HistoryQuery, ParticipantStatus, SquareSnapshot } from './square-facade.js';
-import type { Participant, OperationControl, SquareAtInput, SquareBuildInput } from './square-facade.js';
-export declare class Square {
-    readonly location: string;
-    private readonly square;
-    private readonly context;
-    private constructor();
-    static at(input: SquareAtInput, control?: OperationControl): Promise<Square>;
-    static build(input: SquareBuildInput): Promise<Square>;
-    static inMemory(input: Omit<SquareBuildInput, 'path'>): Square;
-    join(name: string, control?: OperationControl): Promise<Participant>;
-    joinWithActivity(name: string, control?: OperationControl): Promise<{
-        readonly participant: Participant;
-        readonly activity: Activity | null;
-    }>;
-    takeoverWithActivity(name: string, control?: OperationControl): Promise<{
-        readonly participant: Participant;
-        readonly activities: readonly Activity[];
-    }>;
-    takeover(name: string, control?: OperationControl): Promise<Participant>;
-    doneOwnedSession(name: string, body: string, expectedEpoch: number, control?: OperationControl): Promise<ExpressResult>;
-    implicitJoin(name: string, control?: OperationControl): Promise<{
-        readonly state: 'joined' | 'active' | 'done';
-        readonly participant?: Participant;
-    }>;
-    participants(): Promise<ParticipantStatus[]>;
-    snapshot(control?: OperationControl): Promise<SquareSnapshot>;
-    history(query?: HistoryQuery, control?: OperationControl): Promise<Activity[]>;
-    recognize(env: NodeJS.ProcessEnv): Promise<Participant | null>;
-    close(): Promise<void>;
-    endOwnedSession(name: string, sessionId: string, expectedEpoch?: number): Promise<ExpressResult | null>;
-    retireEndedSessionRoutes(sessionId: string): Promise<void>;
-}

package/dist/square-wiring.js

@@ -1,109 +0,0 @@
-import { closeOpenSquare } from './open-square.js';
-import { buildMemorySquare, buildSquare, openSquare } from './square-file-adapter.js';
-import { catchUp, done, endOwnedSession, express, hold, ignore, implicitJoin, join, takeover, listen, listening, resume, retireEndedSessionRoutes, } from './square-actions.js';
-import { history, participantHistory, participants, snapshot } from './views.js';
-import { currentParticipant } from './views.js';
-import { projectSessionBindings } from './square-projections.js';
-import { sessionIdsFromEnvironment } from './participant-identity.js';
-class ParticipantHandle {
-    name;
-    square;
-    context;
-    constructor(name, square, context) {
-        this.name = name;
-        this.square = square;
-        this.context = context;
-    }
-    express(body, options, control) {
-        return express(this.context, this.name, body, options, control);
-    }
-    listen(target, control) {
-        return listen(this.context, this.name, target, control);
-    }
-    ignore(target, control) {
-        return ignore(this.context, this.name, target, control);
-    }
-    listening(control) {
-        return listening(this.context, this.name, control);
-    }
-    catch(options, control) {
-        return catchUp(this.context, this.name, options, undefined, control);
-    }
-    history(query, control) {
-        return participantHistory(this.square, this.name, query, control);
-    }
-    hold(reason, control) {
-        return hold(this.context, this.name, reason, control);
-    }
-    resume(control) {
-        return resume(this.context, this.name, control);
-    }
-    done(body, control) {
-        return done(this.context, this.name, body, {}, control);
-    }
-}
-export class Square {
-    location;
-    square;
-    context;
-    constructor(location, square) {
-        this.location = location;
-        this.square = square;
-        this.context = { ...square, location };
-    }
-    static async at(input, control) {
-        return new Square(input.path, await openSquare(input.path, input, control));
-    }
-    static async build(input) {
-        return new Square(input.path, await buildSquare(input.path, input));
-    }
-    static inMemory(input) {
-        return new Square('memory', buildMemorySquare(input));
-    }
-    async join(name, control) {
-        const joined = await join(this.context, name, control);
-        return new ParticipantHandle(joined.name, this.square, this.context);
-    }
-    async joinWithActivity(name, control) {
-        const joined = await join(this.context, name, control);
-        return { participant: new ParticipantHandle(joined.name, this.square, this.context), activity: joined.activity };
-    }
-    async takeoverWithActivity(name, control) {
-        const result = await takeover(this.context, name, [], control);
-        return { participant: new ParticipantHandle(result.name, this.square, this.context), activities: result.activities };
-    }
-    async takeover(name, control) {
-        return (await this.takeoverWithActivity(name, control)).participant;
-    }
-    doneOwnedSession(name, body, expectedEpoch, control) {
-        return done(this.context, name, body, { expectedEpoch }, control);
-    }
-    async implicitJoin(name, control) {
-        const joined = await implicitJoin(this.context, name, control);
-        return joined.state === 'done'
-            ? { state: joined.state }
-            : { state: joined.state, participant: new ParticipantHandle(joined.name, this.square, this.context) };
-    }
-    participants() { return participants(this.square); }
-    snapshot(control) { return snapshot(this.square, control); }
-    history(query, control) { return history(this.square, query, control); }
-    async recognize(env) {
-        if (this.square.hostLedger === undefined)
-            return null;
-        const sessions = sessionIdsFromEnvironment(env);
-        if (sessions.length === 0)
-            return null;
-        const candidates = (await Promise.all(sessions.map((sessionId) => projectSessionBindings({
-            hostLedger: this.square.hostLedger,
-            location: this.square.location,
-            sessionId,
-        })))).flat();
-        if (candidates.length !== 1)
-            return null;
-        const canonicalName = await currentParticipant(this.square, candidates[0].participant);
-        return canonicalName === undefined ? null : new ParticipantHandle(canonicalName, this.square, this.context);
-    }
-    close() { return closeOpenSquare(this.square); }
-    endOwnedSession(name, sessionId, expectedEpoch) { return endOwnedSession(this.context, name, sessionId, expectedEpoch); }
-    retireEndedSessionRoutes(sessionId) { return retireEndedSessionRoutes(this.context, sessionId); }
-}

package/dist/watch.d.ts

@@ -1,8 +0,0 @@
-import { type WatchOptions } from './model.js';
-interface WatchCallerContext {
-    readonly cwd: string;
-    readonly env: NodeJS.ProcessEnv;
-}
-/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
-export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions, caller?: WatchCallerContext): Promise<boolean | undefined>;
-export {};