@astrosheep/square 0.3.5 → 0.3.6

package/dist/square-application.js

@@ -1,107 +1,139 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { renderArtifactAct, renderSquare } from './artifact.js';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { emptyRuntimeState, loadRuntimeSidecar, loadSquare, mergeRuntimeState, renderArtifactAct, renderSquare, renderSquareDoc, saveRuntimeSidecar } from './artifact.js';
 import { coreCompact, coreDone, coreHold, coreResume, decideAct, decideJoin, resolveKnownName } from './decisions.js';
-import { partitionPendingDeliveries } from './delivery-health.js';
-import { planRepair } from './doctor.js';
 import { dispatchActNotifications } from './notifications.js';
-import { squareStore } from './square-store.js';
-import { actId, freshWatchLease, touchPresenceCursor } from './runtime.js';
-/**
- * Publish a dependent persistence file before the Square document. A retained
- * backup lets a failed document commit restore the prior file exactly.
- */
-function prepareFileReplacement(filePath, text) {
-    const parent = path.dirname(filePath);
-    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    const stage = path.join(parent, `.${path.basename(filePath)}.${token}.stage`);
-    const backup = path.join(parent, `.${path.basename(filePath)}.${token}.previous`);
-    let replaced = false;
-    let hadOriginal = false;
-    try {
-        fs.writeFileSync(stage, text);
-        hadOriginal = fs.existsSync(filePath);
-        if (hadOriginal)
-            fs.renameSync(filePath, backup);
-        fs.renameSync(stage, filePath);
-        replaced = true;
-    }
-    catch (error) {
+import { planRepair } from './doctor.js';
+import { stageReplacement } from './harness-stage.js';
+import { SquareError } from './model.js';
+import { advanceCursor, freshWatchLease, LOCK_RETRY_MS, LOCK_STALE_MS, removeWatchLease, touchPresenceCursor, watchLease, writeWatchLease } from './runtime.js';
+/** The only persistence primitive: one per-square lock, one Markdown write, one sidecar write. */
+export async function withSquareLock(squarePath, fn) {
+    const lockPath = `${squarePath}.lock`;
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    while (true) {
+        let fd;
         try {
-            fs.rmSync(stage, { force: true });
+            fd = fs.openSync(lockPath, 'wx');
+            fs.writeFileSync(fd, `${process.pid}\n${Date.now()}\n`, 'utf8');
         }
-        catch { }
-        if (hadOriginal && fs.existsSync(backup) && !fs.existsSync(filePath)) {
+        catch (error) {
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { }
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch { }
+            }
+            const errno = error;
+            if (errno.code !== 'EEXIST')
+                throw error;
             try {
-                fs.renameSync(backup, filePath);
+                if (Date.now() - fs.statSync(lockPath).mtimeMs > LOCK_STALE_MS)
+                    fs.unlinkSync(lockPath);
+            }
+            catch { }
+            await sleep(LOCK_RETRY_MS);
+            continue;
+        }
+        fs.closeSync(fd);
+        try {
+            return await fn();
+        }
+        finally {
+            try {
+                fs.unlinkSync(lockPath);
             }
             catch { }
         }
-        throw error;
     }
-    return {
-        rollback() {
-            if (replaced)
-                fs.rmSync(filePath, { force: true });
-            if (hadOriginal && fs.existsSync(backup))
-                fs.renameSync(backup, filePath);
-        },
-        finalize() {
-            fs.rmSync(backup, { force: true });
-        },
-    };
+}
+export function writeSquareDoc(squarePath, doc) {
+    const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
+    fs.writeFileSync(temporary, renderSquareDoc(doc));
+    fs.renameSync(temporary, squarePath);
+    saveRuntimeSidecar(squarePath, doc.runtime);
+}
+export function appendAct(squarePath, doc, act) {
+    const stored = applyActs(doc, [act])[0];
+    writeSquareDoc(squarePath, doc);
+    return stored;
+}
+function applyActs(doc, acts, mutateRuntime) {
+    const stored = [];
+    for (const act of acts) {
+        const item = { ...act, index: doc.runtime.nextActIndex };
+        doc.runtime.nextActIndex++;
+        doc.acts.push(item);
+        if (item.actor !== undefined)
+            touchPresenceCursor(doc, item.actor, item.at, item.index);
+        stored.push(item);
+    }
+    mutateRuntime?.(doc);
+    return stored;
+}
+/**
+ * Publish a dependent persistence file before the Square document. A retained
+ * backup lets a failed document commit restore the prior file exactly.
+ */
+function prepareAppend(filePath, block, existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '') {
+    return stageReplacement(filePath, (stage) => {
+        fs.writeFileSync(stage, `${existing}${existing === '' ? '' : '\n'}${block}\n`);
+    });
 }
 function plan(doc, intent) {
     switch (intent.type) {
         case 'join': {
             const decision = decideJoin(doc, intent.name, intent.now);
-            return { result: decision, acts: [decision.joinAct], afterCommit: [] };
+            return { result: decision, acts: [decision.joinAct] };
         }
         case 'say': {
             const decision = decideAct(doc, intent);
             return {
                 result: decision,
                 acts: decision.type === 'sent' ? [decision.act] : [],
-                afterCommit: [],
             };
         }
         case 'hold':
-            return { result: undefined, acts: [coreHold(doc, intent.actor, intent.body, intent.now)], afterCommit: [] };
+            return { result: undefined, acts: [coreHold(doc, intent.actor, intent.body, intent.now)] };
         case 'resume':
-            return { result: undefined, acts: [coreResume(doc, intent.actor, intent.now)], afterCommit: [] };
+            return { result: undefined, acts: [coreResume(doc, intent.actor, intent.now)] };
         case 'done':
-            return { result: undefined, acts: [coreDone(doc, intent.name, intent.body, intent.now)], afterCommit: [] };
+            return { result: undefined, acts: [coreDone(doc, intent.name, intent.body, intent.now)] };
         case 'lease': {
             const name = resolveKnownName(doc, intent.name);
             const existing = freshWatchLease(doc, name, intent.at);
             if (existing !== undefined && !intent.force) {
-                return { result: { type: 'active', lease: existing }, acts: [], afterCommit: [] };
+                return { result: { type: 'active', lease: existing }, acts: [] };
             }
             return {
                 result: { type: 'started', name, replaced: existing !== undefined },
                 acts: [],
-                mutateRuntime: (runtime) => {
-                    runtime.leases[name] = {
+                mutateRuntime: (nextDoc) => {
+                    writeWatchLease(nextDoc, name, {
                         leaseId: intent.leaseId,
+                        ...(intent.ownerId === undefined ? {} : { ownerId: intent.ownerId }),
                         heartbeatAt: intent.at,
                         expiresAt: intent.expiresAt,
                         ...(intent.filter === undefined ? {} : { filter: intent.filter }),
-                    };
-                    touchPresenceCursor(doc, name, intent.at, 'watch');
+                    });
+                    touchPresenceCursor(nextDoc, name, intent.at);
                 },
-                afterCommit: [],
             };
         }
         case 'release-lease': {
             const name = resolveKnownName(doc, intent.name);
-            if (doc.runtime.leases[name]?.leaseId !== intent.leaseId) {
-                return { result: { released: false }, acts: [], afterCommit: [] };
+            if (watchLease(doc, name)?.leaseId !== intent.leaseId) {
+                return { result: { released: false }, acts: [] };
             }
             return {
                 result: { released: true },
                 acts: [],
-                mutateRuntime: (runtime) => { delete runtime.leases[name]; },
-                afterCommit: [],
+                mutateRuntime: (nextDoc) => { removeWatchLease(nextDoc, name, intent.leaseId); },
             };
         }
         case 'consume': {
@@ -109,15 +141,7 @@ function plan(doc, intent) {
             return {
                 result: { name },
                 acts: [],
-                mutateRuntime: (runtime) => {
-                    const current = runtime.cursors[name];
-                    runtime.cursors[name] = {
-                        consumedThroughIndex: Math.max(current?.consumedThroughIndex ?? -1, intent.throughIndex),
-                        updatedAt: Math.max(current?.updatedAt ?? 0, intent.at),
-                        source: intent.source ?? 'watch',
-                    };
-                },
-                afterCommit: [],
+                mutateRuntime: (nextDoc) => { advanceCursor(nextDoc, name, intent.throughIndex, intent.at); },
             };
         }
         case 'compact': {
@@ -134,36 +158,8 @@ function plan(doc, intent) {
                         const block = archive
                             .map((act, index) => renderArtifactAct(act, { first: existing === '' && index === 0 }))
                             .join('\n');
-                        return prepareFileReplacement(intent.archivePath, `${existing}${existing === '' ? '' : '\n'}${block}\n`);
+                        return prepareAppend(intent.archivePath, block, existing);
                     },
-                afterCommit: [],
-            };
-        }
-        case 'reconcile-delivery-backlog': {
-            const { recent, historical } = partitionPendingDeliveries('', { now: intent.now, doc });
-            const actor = intent.actor ?? 'doctor --fix reconcile-backlog';
-            const receipts = historical.filter((item) => doc.runtime.mentionReceipts[item.recipient]?.[actId(item.actIndex)]?.status !== 'delivered');
-            const result = { reconciled: receipts.length, skippedRecent: recent.length, items: historical };
-            return {
-                result,
-                acts: [],
-                ...(receipts.length === 0
-                    ? {}
-                    : {
-                        mutateRuntime: (runtime) => {
-                            for (const item of receipts) {
-                                const recipientReceipts = runtime.mentionReceipts[item.recipient] ?? {};
-                                recipientReceipts[actId(item.actIndex)] = {
-                                    status: 'delivered',
-                                    at: intent.now,
-                                    reason: 'reconciled',
-                                    actor,
-                                };
-                                runtime.mentionReceipts[item.recipient] = recipientReceipts;
-                            }
-                        },
-                    }),
-                afterCommit: [],
             };
         }
         case 'repair':
@@ -174,36 +170,22 @@ function plan(doc, intent) {
                 preparePersistence: intent.quarantine === undefined || intent.quarantine.blocks.length === 0
                     ? undefined
                     : () => {
-                        const existing = fs.existsSync(intent.quarantine.path) ? fs.readFileSync(intent.quarantine.path, 'utf8') : '';
                         const block = intent.quarantine.blocks.join('\n\n');
-                        return prepareFileReplacement(intent.quarantine.path, `${existing}${existing === '' ? '' : '\n'}${block}\n`);
+                        return prepareAppend(intent.quarantine.path, block);
                     },
-                afterCommit: [],
             };
     }
 }
-async function runEffects(squarePath, effects) {
-    for (const effect of effects) {
-        if (effect.type === 'dispatch-act-notifications') {
-            await dispatchActNotifications(squarePath, effect.item);
-        }
-    }
-}
 function commitPlan(squarePath, doc, planned) {
     const nextDoc = planned.replaceDoc ?? doc;
-    const applied = squareStore.apply(nextDoc, planned.acts, planned.mutateRuntime);
-    const afterCommit = [
-        ...planned.afterCommit,
-        ...applied.acts.map((item) => ({ type: 'dispatch-act-notifications', item })),
-    ];
-    const committed = { result: planned.result, acts: applied.acts, afterCommit };
+    const committed = { result: planned.result, acts: applyActs(nextDoc, planned.acts, planned.mutateRuntime) };
     if (planned.acts.length === 0 && planned.mutateRuntime === undefined && planned.replaceDoc === undefined) {
         return committed;
     }
     let persistence;
     try {
         persistence = planned.preparePersistence?.();
-        squareStore.commitOnce(squarePath, nextDoc, committed);
+        writeSquareDoc(squarePath, nextDoc);
         persistence?.finalize();
         return committed;
     }
@@ -217,31 +199,56 @@ function commitPlan(squarePath, doc, planned) {
 }
 /** The one mutation pipeline shared by package and CLI adapters. */
 export async function execute(squarePath, intent) {
-    const committed = await squareStore.transact(squarePath, (doc) => commitPlan(squarePath, doc, plan(doc, intent)));
-    await runEffects(squarePath, committed.afterCommit);
+    const committed = await withSquareLock(squarePath, () => {
+        const doc = loadSquare(squarePath);
+        return commitPlan(squarePath, doc, plan(doc, intent));
+    });
+    for (const act of committed.acts) {
+        if (act.kind === 'say')
+            await dispatchActNotifications(squarePath, act);
+    }
     return committed;
 }
 /** Application-owned artifact creation; adapters provide validated options and stdin text only. */
 export async function createSquare(squarePath, options, snippet) {
-    await squareStore.create(squarePath, {
-        force: options.force,
-        text: renderSquare(options, snippet),
-        result: undefined,
-    });
-}
-export async function reconcileBacklog(squarePath, now = Date.now()) {
-    const committed = await execute(squarePath, {
-        type: 'reconcile-delivery-backlog',
-        now,
+    await withSquareLock(squarePath, () => {
+        if (fs.existsSync(squarePath) && !options.force) {
+            throw new SquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
+        }
+        const temporary = path.join(path.dirname(squarePath), `.${path.basename(squarePath)}.${process.pid}.${Date.now()}.tmp`);
+        fs.mkdirSync(path.dirname(squarePath), { recursive: true });
+        fs.writeFileSync(temporary, renderSquare(options, snippet));
+        fs.renameSync(temporary, squarePath);
+        saveRuntimeSidecar(squarePath, emptyRuntimeState(0));
     });
-    return committed.result;
 }
 /** Keep artifact repair planning and dependent quarantine persistence inside the application boundary. */
 export async function repairSquare(squarePath) {
-    const result = await squareStore.transactText(squarePath, (text) => {
+    const result = await withSquareLock(squarePath, () => {
+        let text;
+        try {
+            text = fs.readFileSync(squarePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                throw new SquareError('not_found', `square file not found: ${squarePath}`);
+            throw error;
+        }
         const repair = planRepair(text);
         if (repair.diagnosis.unfixable || repair.repaired === undefined)
-            return { repair, afterCommit: [] };
+            return { repair };
+        // Repair changes Markdown only. Keep the sidecar's runtime metadata and
+        // merge history boundaries so a doctor run cannot erase delivery state or
+        // reuse a stable activity index.
+        const sidecarRuntime = loadRuntimeSidecar(squarePath, repair.repaired.doc.runtime);
+        const indexesPreserved = repair.diagnosis.acts.every(({ act }, index) => repair.repaired.doc.acts[index]?.index === act.index);
+        if (indexesPreserved) {
+            repair.repaired.doc.runtime = mergeRuntimeState(repair.repaired.doc.runtime, sidecarRuntime);
+        }
+        else {
+            repair.repaired.doc.runtime = emptyRuntimeState(Math.max(repair.repaired.doc.runtime.nextActIndex, sidecarRuntime.nextActIndex));
+            repair.repaired.actions.push({ message: 'reset runtime delivery metadata because act indexes changed' });
+        }
         const quarantinePath = squarePath.replace(/\.md$/, '') + '.quarantine.md';
         const intent = {
             type: 'repair',
@@ -250,10 +257,8 @@ export async function repairSquare(squarePath) {
                 ? {}
                 : { quarantine: { path: quarantinePath, blocks: repair.repaired.quarantinedBlocks } }),
         };
-        const committed = commitPlan(squarePath, repair.repaired.doc, plan(repair.repaired.doc, intent));
-        return { repair, afterCommit: committed.afterCommit };
+        commitPlan(squarePath, repair.repaired.doc, plan(repair.repaired.doc, intent));
+        return { repair };
     });
-    await runEffects(squarePath, result.afterCommit);
     return result.repair;
 }
-export const application = { execute, plan };

package/dist/square-core.js

@@ -26,14 +26,6 @@ function touchParticipant(byKey, ordered, actor) {
     ordered.push(created);
     return created;
 }
-export function isWarm(lastSeen, now, threshold) {
-    if (lastSeen === undefined)
-        return false;
-    if (!Number.isFinite(lastSeen) || !Number.isFinite(now) || !Number.isFinite(threshold) || threshold <= 0)
-        return false;
-    const delta = now - lastSeen;
-    return delta >= 0 && delta <= threshold;
-}
 function pushThrottleAt(state, at) {
     if (typeof at === 'number' && Number.isFinite(at))
         state.throttleActivityAts.push(at);
@@ -59,7 +51,7 @@ function bellRecentAt(state, actor, at, windowMs) {
     }
     return latest;
 }
-export function fold(acts, options = {}) {
+export function fold(acts) {
     const ordered = [];
     const byKey = new Map();
     const hold = { active: false };
@@ -168,12 +160,12 @@ export function validate(state, act, options = {}) {
             return { ok: true };
     }
 }
-export function perceive(state, act, viewer, options = {}) {
+export function perceive(state, act, viewer) {
     void state;
     if (act.kind !== 'say')
         return 'full';
     const actor = act.actor;
-    if ((options.includeActor ?? true) && sameName(actor, viewer))
+    if (sameName(actor, viewer))
         return 'full';
     if (act.reach === undefined || act.reach === 'bell')
         return 'full';

package/dist/stream.js

@@ -1,149 +1,50 @@
-// stream.ts — live activity feed
 import fs from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { loadSquare } from './artifact.js';
-import { planActNotifications } from './notifications.js';
+import { planActNotifications } from './delivery.js';
 import { sameName } from './model.js';
-import { indexedDelta } from './activity-feed.js';
-import { SLEEP_MS, actStableIndex, inSquareCount, latestIndexedActIndex, nowMs, rosterNames, sayNumberFor } from './runtime.js';
 import { quoteShell } from './presentation.js';
-import { enableRawMode, disableRawMode, enterAlternateScreen, leaveAlternateScreen, clearScreen, hideCursor, showCursor, renderStreamHeader, renderStreamEvent, renderWaiting, cursorUp, clearLine, } from './terminal.js';
-const INITIAL_DUMP = 20;
+import { SLEEP_MS } from './runtime.js';
 export function streamNotificationFor(doc, item, recipient) {
     return planActNotifications(doc, item).find((notification) => sameName(notification.recipient, recipient));
 }
-export function matchesStreamRecipient(doc, item, recipient) {
-    return streamNotificationFor(doc, item, recipient) !== undefined;
-}
-function renderDump(squarePath, doc, events, now) {
-    const relevant = events.filter((item) => item.act.kind !== 'read');
-    const active = inSquareCount(doc);
-    if (relevant.length === 0)
-        return `${renderStreamHeader(squarePath, rosterNames(doc).length, active)}\n\n  (no activity yet)\n`;
-    const header = renderStreamHeader(squarePath, rosterNames(doc).length, active);
-    const body = relevant.map((item) => renderStreamEvent(item.act, now, item.act.kind === 'say' ? sayNumberFor(doc.acts, item.act) : undefined)).join('');
-    return `${header}\n${body}`;
+function streamRows(squarePath, doc, cursor, recipient) {
+    return doc.acts.filter((act) => act.index > cursor).flatMap((act) => {
+        const notification = recipient === undefined ? undefined : streamNotificationFor(doc, act, recipient);
+        if (recipient !== undefined && notification === undefined)
+            return [];
+        return [JSON.stringify({
+                seq: act.index,
+                square: squarePath,
+                ...act,
+                ...(notification === undefined ? {} : { route: notification.route }),
+            })];
+    });
 }
-export async function cmdStreamNdjson(squarePath, forName) {
+/** Machine-readable tailing stays available; interactive terminal rendering was retired. */
+export async function cmdStreamNdjson(squarePath, recipient) {
     if (!fs.existsSync(squarePath)) {
         process.stderr.write(`square not found: ${squarePath}\n`);
-        process.exit(2);
+        process.exitCode = 2;
+        return;
     }
-    let doc = loadSquare(squarePath);
     let cursor = -1;
-    const emit = (events) => {
-        for (const { act, index } of events) {
-            const item = { act, index };
-            const notification = forName ? streamNotificationFor(doc, item, forName) : undefined;
-            if (forName && !notification)
-                continue;
-            process.stdout.write(`${JSON.stringify({
-                seq: index,
-                square: squarePath,
-                ...act,
-                ...(notification ? { via: notification.via } : {}),
-            })}\n`);
-        }
-    };
-    const backlog = indexedDelta(doc.acts, cursor);
-    emit(backlog);
-    cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
     while (true) {
-        await sleep(SLEEP_MS);
         try {
-            doc = loadSquare(squarePath);
+            const doc = loadSquare(squarePath);
+            for (const row of streamRows(squarePath, doc, cursor, recipient))
+                process.stdout.write(`${row}\n`);
+            cursor = Math.max(cursor, ...doc.acts.map((act) => act.index));
         }
         catch {
-            // Transient read failure (e.g. concurrent writer mid-rename) — retry next poll.
-            continue;
+            // A concurrent artifact replacement is retried on the next poll.
         }
-        const delta = indexedDelta(doc.acts, cursor);
-        if (delta.length === 0)
-            continue;
-        emit(delta);
-        cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
+        await sleep(SLEEP_MS);
     }
 }
-async function readKey() {
-    return new Promise((resolve) => {
-        const finish = (value) => {
-            clearTimeout(timer);
-            process.stdin.removeListener('data', onData);
-            resolve(value);
-        };
-        const onData = (chunk) => finish(chunk.toString());
-        const timer = setTimeout(() => finish(null), 100);
-        timer.unref();
-        process.stdin.once('data', onData);
-    });
-}
 export async function cmdStream(squarePath) {
-    if (!fs.existsSync(squarePath)) {
-        process.stderr.write(`square not found: ${squarePath}\n`);
-        process.exit(2);
-    }
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        process.stderr.write('✕ interactive stream requires a TTY\n');
-        process.stderr.write(`» square --square-path ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
-        process.exit(2);
-    }
-    let doc = loadSquare(squarePath);
-    let cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
-    let stoppedBy;
-    const stop = (signal) => {
-        stoppedBy = signal;
-    };
-    const onSigint = () => stop('SIGINT');
-    const onSigterm = () => stop('SIGTERM');
-    process.once('SIGINT', onSigint);
-    process.once('SIGTERM', onSigterm);
-    enterAlternateScreen();
-    enableRawMode();
-    hideCursor();
-    clearScreen();
-    try {
-        const allIndexed = doc.acts.map((act) => ({ act, index: actStableIndex(act) }));
-        const initial = allIndexed.filter((item) => item.act.kind !== 'read').slice(-INITIAL_DUMP);
-        cursor = Math.max(cursor, latestIndexedActIndex(initial));
-        process.stdout.write(renderDump(squarePath, doc, initial, nowMs()));
-        process.stdout.write(renderWaiting());
-        while (stoppedBy === undefined) {
-            const key = await readKey();
-            if (key === 'q' || key === '\x1b' || key === '\x03')
-                break;
-            try {
-                doc = loadSquare(squarePath);
-            }
-            catch {
-                await sleep(SLEEP_MS);
-                continue;
-            }
-            const delta = indexedDelta(doc.acts, cursor);
-            if (delta.length === 0) {
-                await sleep(SLEEP_MS);
-                continue;
-            }
-            cursor = latestIndexedActIndex(doc.acts.map((act) => ({ act, index: actStableIndex(act) })));
-            cursorUp(1);
-            clearLine();
-            const fresh = nowMs();
-            for (const item of delta) {
-                if (item.act.kind !== 'read') {
-                    process.stdout.write(renderStreamEvent(item.act, fresh, item.act.kind === 'say' ? sayNumberFor(doc.acts, item.act) : undefined));
-                }
-            }
-            process.stdout.write(renderWaiting());
-        }
-    }
-    finally {
-        process.off('SIGINT', onSigint);
-        process.off('SIGTERM', onSigterm);
-        disableRawMode();
-        showCursor();
-        leaveAlternateScreen();
-        showCursor();
-    }
-    if (stoppedBy !== undefined)
-        process.exitCode = stoppedBy === 'SIGINT' ? 130 : 143;
+    process.stderr.write('✕ interactive stream was removed\n');
+    process.stderr.write(`» square --square-path ${quoteShell(path.resolve(squarePath))} stream --ndjson\n`);
+    process.exitCode = 2;
 }