@astrosheep/square 0.3.44 → 0.3.46

package/dist/ports.d.ts

@@ -11,10 +11,7 @@ export interface SquareArtifactPort {
     transact<R>(fn: (state: SquareState, version: number) => {
         state?: SquareState;
         result: R;
-    } | Promise<{
-        state?: SquareState;
-        result: R;
-    }>): Promise<R>;
+    }): Promise<R>;
     changed(sinceVersion: number, timeoutMs: number): Promise<boolean>;
     close(): Promise<void>;
 }

package/dist/square-file-adapter.js

@@ -1,17 +1,18 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { createSquareState, probeSquareFile, writeSquareSnapshot, withSquareFileLock, openSquareCell, createMemoryCell, } from './square-storage.js';
+import { createSquareState, createSquareSnapshot, probeSquareFile, writeSquareSnapshot, openSquareCell, createMemoryCell, } from './square-storage.js';
 import { InternalSquareError, SquareError, } from './model.js';
 import { closeOpenSquare } from './open-square.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) {
-    await withSquareFileLock(squarePath, async () => {
-        if (await fs.promises.access(squarePath).then(() => true, () => false) && !options.force) {
-            throw new InternalSquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
-        }
-        await writeSquareSnapshot(squarePath, await createSquareState(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

package/dist/square-state.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,141 @@
+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 validateObservation(value) {
+    return isObject(value) && hasExactKeys(value, ['state', 'at']) && value.state === 'seen' && isFiniteNumber(value.at);
+}
+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 && validateObservation(observation)))
+        && 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,20 +1,17 @@
 import { createSquareState, diagnoseSquareFile as diagnoseArtifactFile } from './artifact.js';
+import type { SquareState } from './model.js';
 import type { StateCell } from './state-cell.js';
-import { type SquareState } from './model.js';
-/**
- * The only production module allowed to cross the .square byte boundary.
- * Consumers receive a SquareState and never need to know which codec or lock
- * protects it.
- */
-export { createSquareState, };
+export { createSquareState };
 export declare function readSquareFile(squarePath: string): Promise<SquareState>;
 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>;
-export declare function withSquareFileLock<T>(squarePath: string, fn: () => T | Promise<T>): Promise<T>;
+/** Race-safe non-force creation for the file adapter. */
+export declare function createSquareSnapshot(squarePath: string, squareState: SquareState): Promise<boolean>;
 /** In-process cell for fast behavior tests and embedded consumers. */
 export declare function createMemoryCell(initial: SquareState): StateCell;
-/** File-backed cell retaining the existing .square codec and lock boundary. */
+/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
 export declare function createFileCell(squarePath: string): StateCell;
-/** Consumer-facing file cell factory; keeps storage choice behind this module. */
+/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
 export declare function openSquareCell(squarePath: string): StateCell;

package/dist/square-storage.js

@@ -1,15 +1,9 @@
-import { setTimeout as sleep } from 'node:timers/promises';
 import fs from 'node:fs';
 import path from 'node:path';
-import { createSquareState, diagnoseSquareFile as diagnoseArtifactFile, loadSquare, probeSquare, writeSquareFile, } from './artifact.js';
-import { withFileLock } from './file-lock.js';
-import { LOCK_RETRY_MS } from './runtime.js';
-/**
- * The only production module allowed to cross the .square byte boundary.
- * Consumers receive a SquareState and never need to know which codec or lock
- * protects it.
- */
-export { createSquareState, };
+import { setTimeout as sleep } from 'node:timers/promises';
+import { isDeepStrictEqual } from 'node:util';
+import { createSquareFile, createSquareState, diagnoseSquareFile as diagnoseArtifactFile, loadSquare, probeSquare, readSquareSnapshot, transactSquareSnapshot, writeSquareFile, } from './artifact.js';
+export { createSquareState };
 async function canonicalPath(squarePath) {
     const absolute = path.resolve(squarePath);
     try {
@@ -22,49 +16,24 @@ async function canonicalPath(squarePath) {
         return path.join(parent, path.basename(absolute));
     }
 }
-async function squareFileExists(squarePath) {
-    try {
-        await fs.promises.access(squarePath);
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return false;
-        throw error;
-    }
-}
-async function withSquareFileReadLock(squarePath, fn) {
-    if (!await squareFileExists(squarePath))
-        return fn();
-    try {
-        return await withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, createParent: false }, fn);
-    }
-    catch (error) {
-        if (!await squareFileExists(squarePath))
-            return fn();
-        throw error;
-    }
-}
 export async function readSquareFile(squarePath) {
-    const canonical = await canonicalPath(squarePath);
-    return withSquareFileReadLock(canonical, () => loadSquare(canonical));
+    return loadSquare(await canonicalPath(squarePath));
 }
 export async function probeSquareFile(squarePath) {
     if (!squarePath.endsWith('.square'))
         return undefined;
-    const canonical = await canonicalPath(squarePath);
-    return withSquareFileReadLock(canonical, () => probeSquare(canonical));
+    return probeSquare(await canonicalPath(squarePath));
 }
 export async function diagnoseSquareFile(squarePath) {
-    const canonical = await canonicalPath(squarePath);
-    return withSquareFileReadLock(canonical, () => diagnoseArtifactFile(canonical));
+    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);
 }
-export async function withSquareFileLock(squarePath, fn) {
-    const canonical = await canonicalPath(squarePath);
-    return withFileLock(`${canonical}.lock`, { retryMs: LOCK_RETRY_MS }, fn);
+/** 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);
@@ -73,6 +42,16 @@ function assertCellOpen(closed) {
     if (closed)
         throw new Error('StateCell 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);
+}
+function isBusy(error) {
+    return error instanceof Error && /database is locked|database is busy|SQLITE_BUSY/i.test(error.message);
+}
 /** In-process cell for fast behavior tests and embedded consumers. */
 export function createMemoryCell(initial) {
     let state = cloneState(initial);
@@ -89,15 +68,21 @@ export function createMemoryCell(initial) {
             waiter.resolve(true);
         }
     }
-    const cell = {
+    return {
         transact(fn) {
             assertCellOpen(closed);
-            let operation;
-            operation = tail.then(() => {
+            const operation = tail.then(() => {
                 assertCellOpen(closed);
-                const working = cloneState(state);
-                const outcome = fn(working, version);
-                if (outcome.state !== undefined) {
+                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();
@@ -110,6 +95,7 @@ export function createMemoryCell(initial) {
         async read() {
             assertCellOpen(closed);
             await tail;
+            assertCellOpen(closed);
             return { state: cloneState(state), version };
         },
         changed(sinceVersion, timeoutMs) {
@@ -122,10 +108,7 @@ export function createMemoryCell(initial) {
                 const waiter = {
                     since: sinceVersion,
                     resolve,
-                    timer: setTimeout(() => {
-                        waiters.delete(waiter);
-                        resolve(false);
-                    }, timeoutMs),
+                    timer: setTimeout(() => { waiters.delete(waiter); resolve(false); }, timeoutMs),
                 };
                 waiters.add(waiter);
             });
@@ -142,93 +125,79 @@ export function createMemoryCell(initial) {
             }
         },
     };
-    return cell;
-}
-async function fileFingerprint(squarePath) {
-    try {
-        const stat = await fs.promises.stat(squarePath);
-        return `${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
-    }
-    catch {
-        return 'missing';
-    }
 }
-/** File-backed cell retaining the existing .square codec and lock boundary. */
+/** SQLite-backed cell. Revisions are read from the authoritative database, not file metadata. */
 export function createFileCell(squarePath) {
     let closed = false;
-    let version = 0;
-    let fingerprint;
-    let cached;
-    let canonicalSquarePath;
-    async function storagePath() {
-        canonicalSquarePath ??= await canonicalPath(squarePath);
-        return canonicalSquarePath;
-    }
-    async function observe() {
-        const next = await fileFingerprint(await storagePath());
-        if (fingerprint === undefined) {
-            fingerprint = next;
-        }
-        else if (next !== fingerprint) {
-            fingerprint = next;
-            cached = undefined;
-            version += 1;
-        }
-        return fingerprint;
+    let storage;
+    let tail = Promise.resolve();
+    const cancel = new AbortController();
+    function storagePath() {
+        storage ??= canonicalPath(squarePath);
+        return storage;
     }
-    async function currentStateUnderLock() {
-        const observed = await observe();
-        if (cached?.fingerprint === observed)
-            return cloneState(cached.state);
-        const decoded = await loadSquare(await storagePath());
-        cached = { fingerprint: observed, state: cloneState(decoded) };
-        return cloneState(cached.state);
+    function abortError() {
+        return new Error('StateCell is closed');
     }
     return {
-        async transact(fn) {
+        transact(fn) {
             assertCellOpen(closed);
-            const canonical = await storagePath();
-            return withFileLock(`${canonical}.lock`, { retryMs: LOCK_RETRY_MS }, async () => {
+            const operation = tail.then(async () => {
                 assertCellOpen(closed);
-                const current = await currentStateUnderLock();
-                const working = cloneState(current);
-                const outcome = fn(working, version);
-                if (outcome.state !== undefined) {
-                    await writeSquareFile(canonical, outcome.state);
-                    fingerprint = await fileFingerprint(canonical);
-                    cached = { fingerprint, state: cloneState(outcome.state) };
-                    version += 1;
-                }
-                return outcome.result;
+                const result = await transactSquareSnapshot(await storagePath(), fn, cancel.signal);
+                return result.result;
             });
+            tail = operation.then(() => undefined, () => undefined);
+            return operation;
         },
         async read() {
             assertCellOpen(closed);
-            return withSquareFileReadLock(await storagePath(), async () => {
-                assertCellOpen(closed);
-                return { state: await currentStateUnderLock(), version };
-            });
+            await tail;
+            assertCellOpen(closed);
+            const snapshot = await readSquareSnapshot(await storagePath(), cancel.signal);
+            return { state: cloneState(snapshot.state), version: snapshot.revision };
         },
         async changed(sinceVersion, timeoutMs) {
             assertCellOpen(closed);
             const deadline = Date.now() + Math.max(0, timeoutMs);
-            while (true) {
-                await observe();
-                if (version > sinceVersion)
-                    return true;
+            while (!closed) {
                 const remaining = deadline - Date.now();
-                if (remaining <= 0)
+                const timeout = AbortSignal.timeout(Math.max(1, remaining));
+                const readSignal = AbortSignal.any([cancel.signal, timeout]);
+                try {
+                    if ((await readSquareSnapshot(await storagePath(), readSignal)).revision > sinceVersion)
+                        return true;
+                }
+                catch (error) {
+                    if (closed || cancel.signal.aborted || timeout.aborted)
+                        return false;
+                    if (!isBusy(error))
+                        throw error;
+                }
+                const nextRemaining = deadline - Date.now();
+                if (nextRemaining <= 0)
                     return false;
-                await sleep(Math.min(25, remaining));
-                assertCellOpen(closed);
+                try {
+                    await sleep(Math.min(25, nextRemaining), undefined, { signal: cancel.signal });
+                }
+                catch (error) {
+                    if (closed || cancel.signal.aborted)
+                        return false;
+                    throw error;
+                }
             }
+            return false;
         },
         async close() {
+            if (closed)
+                return;
             closed = true;
+            cancel.abort(abortError());
+            await tail;
         },
     };
 }
-/** Consumer-facing file cell factory; keeps storage choice behind this module. */
+/** Consumer-facing file cell factory; keeps SQLite framing behind this module. */
 export function openSquareCell(squarePath) {
     return createFileCell(squarePath);
 }

package/dist/state-cell.d.ts

@@ -4,10 +4,7 @@ export interface StateCell {
     transact<R>(fn: (state: SquareState, version: number) => {
         state?: SquareState;
         result: R;
-    } | Promise<{
-        state?: SquareState;
-        result: R;
-    }>): Promise<R>;
+    }): Promise<R>;
     read(): Promise<{
         state: SquareState;
         version: number;

package/guides/participant-ownership.md

@@ -110,7 +110,7 @@ row.
 1. Resolve the requested name and collect the currently active bindings for
    that name. The current session is excluded from the old-owner set only when
    it is already the owner and this is a reconnect, not a kick.
-2. Under the artifact lock, commit two lifecycle activities as one transaction:
+2. In one artifact transaction, commit two lifecycle activities:
    `done` for the standing participant, followed immediately by `join` for the
    reclaimed name. If this transaction cannot commit, nothing is kicked.
 3. In the same artifact transaction, remove every route for the kicked
@@ -152,8 +152,8 @@ owner. It must not append a second `done` for the new owner.
 ## Concurrency and Recovery
 
 The artifact transaction serializes participant lifecycle activities. The host
-ledger lock serializes binding rows. These locks protect different facts and
-must not be replaced with a copied sidecar or a display-level mutex.
+ledger lock serializes binding rows. They protect different facts and must not
+be replaced with a copied sidecar or a display-level mutex.
 
 The safe ordering is:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.44",
+  "version": "0.3.46",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -10,7 +10,6 @@
     "dist",
     "guides",
     "skills/square",
-    "skills/brainstorm",
     "claude-plugin",
     "extensions",
     "codex-plugin"
@@ -38,7 +37,7 @@
   "author": "astrosheep",
   "license": "MIT",
   "engines": {
-    "node": ">=22.5.0"
+    "node": "^22.16.0 || >=24.0.0"
   },
   "devDependencies": {
     "@getpaseo/client": "^0.3.1",