@astrosheep/square 0.3.69 → 0.3.71

package/dist/activity.d.ts

@@ -1,14 +0,0 @@
-export interface ActivityOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    force?: boolean;
-    noWait?: boolean;
-    noMention?: boolean;
-    mentions?: readonly string[];
-    reach?: import('./model.js').Reach;
-    reply?: string;
-}
-export declare function saveActivityDraft(squarePath: string, name: string, body: string): string;
-/** Retry commands preserve the original reach, reply, wait and force choices. */
-export declare function activityRetryCommand(squarePath: string, name: string, opts: ActivityOptions, force?: boolean): string;
-export declare function cmdActivity(squarePath: string, name: string, activity: string, resolveBody: (arg: string) => string, opts: ActivityOptions): Promise<void>;

package/dist/activity.js

@@ -1,248 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { SquareError, isSquareError, validateName } from './model.js';
-import { expressHintLine, formatRefusal, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
-import { nowMs, SLEEP_MS } from './runtime.js';
-import { unreadActivitySummaries } from './decisions.js';
-import { openSquare } from './square-file-adapter.js';
-import { closeOpenSquare } from './open-square.js';
-import { createSquareApplication } from './square-application.js';
-import { activityPresentation, resolveParticipant } from './views.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { formatDuration } from './time.js';
-import { style } from './tty-style.js';
-import { hostLedgerForEnv } from './registry.js';
-import { createDefaultWakeTransport } from './notifications.js';
-export function saveActivityDraft(squarePath, name, body) {
-    const draftDir = path.join(path.dirname(squarePath), 'drafts');
-    fs.mkdirSync(draftDir, { recursive: true });
-    const hash = crypto.createHash('sha256').update(body).digest('hex').slice(0, 8);
-    const stamp = new Date(nowMs()).toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[:.]/g, '-');
-    const namePart = name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '') || 'participant';
-    const base = `${stamp}-${namePart}-${hash}`;
-    for (let i = 0;; i++) {
-        const filename = `${base}${i === 0 ? '' : `-${i}`}.md`;
-        const target = path.join(draftDir, filename);
-        try {
-            fs.writeFileSync(target, body, { flag: 'wx' });
-            return target;
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST')
-                throw error;
-        }
-    }
-}
-/** Retry commands preserve the original reach, reply, wait and force choices. */
-export function activityRetryCommand(squarePath, name, opts, force = opts.force ?? false) {
-    const reach = opts.reach === 'bell' ? ' --bell'
-        : opts.mentions?.length ? opts.mentions.map((target) => ` --mention ${quoteShell(target)}`).join('')
-            : opts.noMention === true ? ' --no-mention'
-                : '';
-    const replyIndex = opts.reply === undefined ? undefined : parseActivityId(opts.reply);
-    const reply = opts.reply === undefined ? '' : ` --reply ${replyIndex === undefined ? quoteShell(opts.reply) : formatActivityId(replyIndex)}`;
-    return `${participantCommandPrefix(squarePath, name)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${reply} -`;
-}
-/**
- * A recipient conflict is the speaker's to edit: the printed recovery drops every
- * mention flag (or keeps the bell) so the retry never repeats the rejected target.
- */
-function mentionRepairCommand(squarePath, name, opts, bell) {
-    const replyIndex = opts.reply === undefined ? undefined : parseActivityId(opts.reply);
-    const reply = opts.reply === undefined ? '' : ` --reply ${replyIndex === undefined ? quoteShell(opts.reply) : formatActivityId(replyIndex)}`;
-    const reach = bell ? ' --bell' : ' --no-mention';
-    return `${participantCommandPrefix(squarePath, name)} express${opts.force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${reply} -`;
-}
-/** A body that is nothing but *gestures* reads as an action, not as speech. */
-function isGestureOnly(body) {
-    return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
-}
-export async function cmdActivity(squarePath, name, activity, resolveBody, opts) {
-    const rawInput = String(resolveBody(activity));
-    const env = { ...(opts.env ?? process.env) };
-    const hostLedger = hostLedgerForEnv(env);
-    const retryCommand = activityRetryCommand(squarePath, name, opts);
-    const forceCommand = activityRetryCommand(squarePath, name, opts, true);
-    let knownName = name;
-    let callerMissing = false;
-    let expressAttempted = false;
-    let landedId;
-    let announcedWait;
-    async function presentation() {
-        const square = await openSquare(squarePath, { clock: nowMs, env, hostLedger });
-        try {
-            return await activityPresentation(square, knownName);
-        }
-        finally {
-            await closeOpenSquare(square);
-        }
-    }
-    try {
-        validateName(name);
-        for (const target of opts.mentions ?? [])
-            validateName(target);
-        if (opts.reply !== undefined && parseActivityId(opts.reply) === undefined) {
-            throw new SquareError('invalid_args', 'Invalid --reply: expected an activity id like act/12');
-        }
-        const reader = await openSquare(squarePath, { clock: nowMs, env, hostLedger });
-        try {
-            knownName = (await resolveParticipant(reader, name)).name;
-        }
-        catch (error) {
-            // The caller name was validated above; invalid_args here means it is absent
-            // from the roster. Keep the join recovery distinct from recipient validation.
-            callerMissing = isSquareError(error) && error.code === 'invalid_args';
-            throw error;
-        }
-        finally {
-            await closeOpenSquare(reader);
-        }
-        const application = createSquareApplication({ cwd: opts.cwd ?? process.cwd(), env, squarePath, clock: nowMs, hostLedger, wakeTransport: await createDefaultWakeTransport(hostLedger, nowMs), participant: name });
-        // The caller is roster-known at this point, so a landed join act is always a
-        // re-entry after done — never a first arrival. Announce it; a silent return
-        // would make `done` a fake exit.
-        const entry = await application.join();
-        const reentered = entry.kind === 'joined' && entry.activity !== null;
-        const before = await presentation();
-        const pendingPublic = before.pendingPublic;
-        expressAttempted = true;
-        const landed = await application.express(rawInput.replace(/\r\n/g, '\n').trim(), {
-            force: opts.force ?? false,
-            noWait: opts.noWait ?? false,
-            ...(opts.mentions === undefined ? {} : { mentions: opts.mentions }),
-            ...(opts.noMention === undefined ? {} : { noMention: opts.noMention }),
-            ...(opts.reach === undefined ? {} : { reach: opts.reach }),
-            // The action boundary validates the raw id before attempting a commit.
-            ...(opts.reply === undefined ? {} : { reply: opts.reply }),
-        }, {
-            onProgress: (progress) => {
-                if (announcedWait === progress.reason)
-                    return;
-                const delayMs = progress.delayMs ?? SLEEP_MS;
-                process.stdout.write(renderExpressWaiting({
-                    reason: progress.reason,
-                    ...(progress.reason === 'throttled' ? { delayMs } : {}),
-                    ...(progress.holder === undefined ? {} : { holder: progress.holder }),
-                    ...(progress.holdReason === undefined ? {} : { holdReason: progress.holdReason }),
-                }) + '\n');
-                announcedWait = progress.reason;
-            },
-        });
-        landedId = landed.activity.id;
-        const fresh = await presentation();
-        const headerCount = fresh.participantCount;
-        const held = fresh.held;
-        const ownActCount = fresh.ownActivityCount;
-        const hasPending = pendingPublic.length > 0;
-        const pendingSpeaker = pendingPublic[0]?.actor;
-        const pendingLead = pendingSpeaker === undefined
-            ? ''
-            : `▲ while you spoke, ${participantIdentity(pendingSpeaker)} said something behind you\n\n`;
-        const pending = hasPending ? `\n\n${pendingLead}${renderPendingFeed([...fresh.activities], [...pendingPublic], knownName, fresh.state)}` : '';
-        const hint = expressHintLine(ownActCount);
-        const receiptId = landed.activity.id;
-        const capCount = fresh.hardCap === null ? '' : ` · ${ownActCount}/${fresh.hardCap}`;
-        const confirmation = landed.activity.reach === 'bell'
-            ? `● you ring the bell — everyone turns · ${receiptId}${style('dim', capCount)}`
-            : `● ${landed.activity.mentions.length > 0
-                ? `you walk over to ${landed.activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
-                : isGestureOnly(landed.activity.body ?? '')
-                    ? 'your gesture lands'
-                    : 'your words land'} — ${receiptId}${style('dim', capCount)}`;
-        const withHint = hint ? `${confirmation}\n${style('dim', hint)}` : confirmation;
-        const replyNotice = landed.replyAuthorNotHere === undefined
-            ? ''
-            : `\n○ ${participantIdentity(landed.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
-        const reentry = reentered ? '● you stepped back into the square\n' : '';
-        process.stdout.write(withPathOutput(squarePath, reentry + withHint + replyNotice + pending, { participantCount: headerCount, held }));
-    }
-    catch (error) {
-        // Save before any recovery read: even a broken artifact must not eat the body.
-        const draftPath = saveActivityDraft(squarePath, name, rawInput);
-        const confirmedUnsent = landedId === undefined && (!expressAttempted || (isSquareError(error) && error.facts?.activityUnsent === true));
-        const fresh = await presentation().catch(() => undefined);
-        const output = { squarePath, name: knownName, draftPath, participantCount: fresh?.participantCount, held: fresh?.held };
-        if (!confirmedUnsent) {
-            process.stderr.write(renderActivityUncertain({ ...output, landedId, detail: error instanceof Error ? error.message : String(error) }));
-            process.exit(1);
-            return;
-        }
-        if (isSquareError(error) && fresh !== undefined) {
-            if (error.code === 'behind') {
-                process.stdout.write(renderActivityBlocked({
-                    ...output,
-                    retryCommand,
-                    forceCommand,
-                    activitySummaries: unreadActivitySummaries(fresh.state, knownName, nowMs()),
-                }));
-                process.exit(1);
-                return;
-            }
-            if (error.code === 'capped') {
-                process.stdout.write(renderActivityLimit({
-                    ...output,
-                    count: fresh.ownActivityCount,
-                    ...(fresh.hardCap === null ? {} : { hardCap: fresh.hardCap }),
-                }));
-                process.exit(1);
-                return;
-            }
-            if (error.code === 'throttled' || error.code === 'held') {
-                process.stdout.write(renderExpressNoWait({
-                    ...output,
-                    reason: error.code,
-                    delayMs: error.facts?.retryAfterMs ?? SLEEP_MS,
-                    ...(error.facts?.holder === undefined ? {} : { holder: error.facts.holder }),
-                    ...(error.facts?.holdReason === undefined ? {} : { holdReason: error.facts.holdReason }),
-                    retryCommand,
-                }));
-                process.exit(1);
-                return;
-            }
-            if (error.code === 'bell_quota') {
-                process.stdout.write(withPathOutput(squarePath, [
-                    '✕ the bell stays quiet for now',
-                    `  · you can ring it again in ${formatDuration(error.facts?.retryAfterMs ?? 1)}`,
-                    `· draft kept: ${draftPath}`,
-                    `  · retry when the bell is ready:`,
-                    `${retryCommand} < ${quoteShell(draftPath)}`,
-                ].join('\n'), output));
-                process.exit(1);
-                return;
-            }
-        }
-        const lines = [error instanceof Error ? error.message : String(error), `· draft kept: ${draftPath}`];
-        const reason = isSquareError(error) ? error.facts?.reason : undefined;
-        // `not_standing` is a flag mention; the body-scan and bell conflicts carry an @name in the draft.
-        const mentionRepair = reason === 'bell_mention_conflict' ? { bell: true, fromBody: true }
-            : reason === 'unmatched_mention' ? { bell: false, fromBody: true }
-                : reason === 'not_standing' ? { bell: false, fromBody: false }
-                    : undefined;
-        if (isSquareError(error)) {
-            if (callerMissing || error.code === 'unknown_participant' || error.code === 'not_joined')
-                lines.push(joinRecoveryCommand(squarePath, name));
-            if (error.code === 'already_joined')
-                lines.push(...takeoverRecoveryLines(squarePath, name));
-            if (mentionRepair !== undefined) {
-                // The draft stays, but the retry no longer carries the target that was refused.
-                lines.push(participantsRecoveryCommand(squarePath));
-                lines.push(mentionRepair.fromBody
-                    ? "  · edit the draft first — the body's @name must be removed or wrapped in backticks:"
-                    : '  · pick someone standing here, or land it bare:');
-                lines.push(`${mentionRepairCommand(squarePath, name, opts, mentionRepair.bell)} < ${quoteShell(draftPath)}`);
-            }
-            else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
-                if (opts.mentions?.length)
-                    lines.push(participantsRecoveryCommand(squarePath));
-                if (opts.reply !== undefined)
-                    lines.push(`${commandPrefix(squarePath)} history --limit 10`);
-            }
-        }
-        if (mentionRepair === undefined) {
-            lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryCommand} < ${quoteShell(draftPath)}`);
-        }
-        process.stderr.write(formatRefusal(squarePath, lines, output));
-        process.exit(2);
-    }
-}

package/dist/square-file-adapter.d.ts

@@ -1,26 +0,0 @@
-export { observeSquareRevision as observeSquareChanges } from './artifact.js';
-import { type BuildOptions, type HardCap } from './model.js';
-import type { OpenSquare } from './open-square.js';
-import type { OperationControl } from './square-facade.js';
-import type { HostLedgerPort, SquareArtifactPort } from './ports.js';
-/** File-owned artifact creation for the CLI and path-backed public facade. */
-export declare function createSquare(squarePath: string, options: BuildOptions & {
-    hardCap: HardCap;
-}, snippet: string): Promise<void>;
-export interface SquareBuildOptions {
-    markdown: string;
-    hardCap?: number | null;
-    throttlePerMinute?: number;
-    clock?: () => number;
-    hostLedger?: HostLedgerPort;
-    wakeTransport?: import('./ports.js').WakeTransportPort;
-    env?: NodeJS.ProcessEnv;
-    /** One caller deadline (e.g. a native hook budget) propagated into artifact busy retries. */
-    signal?: AbortSignal;
-}
-export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'>, control?: OperationControl): Promise<OpenSquare>;
-export declare function probeSquare(squarePath: string): Promise<OpenSquare | undefined>;
-export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
-export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
-/** A projection reads and validates its snapshot once; no preliminary duplicate read. */
-export declare function openSquareArtifact(squarePath: string, signal?: AbortSignal): SquareArtifactPort;

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;