@north-light/crouter 0.3.233 → 0.3.235

package/dist/core/canvas/focuses.js

@@ -23,9 +23,7 @@ function focusFrom(r) {
         node_id: r['node_id'],
     };
 }
-// ---------------------------------------------------------------------------
 // Atomic setters — each one a single-statement INSERT/UPDATE/DELETE.
-// ---------------------------------------------------------------------------
 /** INSERT a viewport. Throws on UNIQUE(node_id) if `node_id` already occupies
  *  another focus (or on PK conflict if `focus_id` exists) — by design. */
 export function openFocusRow(focus_id, pane, session, node_id) {
@@ -50,9 +48,7 @@ export function setFocusPane(focus_id, pane, session) {
 export function closeFocusRow(focus_id) {
     openDb().prepare('DELETE FROM focuses WHERE focus_id = ?').run(focus_id);
 }
-// ---------------------------------------------------------------------------
 // Reads.
-// ---------------------------------------------------------------------------
 /** The focus a node occupies (≤1, UNIQUE node_id), or null. */
 export function getFocusByNode(node_id) {
     const r = openDb()

package/dist/core/canvas/history.js

@@ -9,6 +9,7 @@
 // node facets (cwd/kind/status) are filtered cheaply against the db FIRST, then
 // only the surviving nodes' artifact files are read. FTS5/bm25 is the future
 // upgrade; the surface above is backend-independent.
+import { envNodeId } from '../../shared/env.js';
 import { statSync, readdirSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 import { getNode, listNodes, view } from './canvas.js';
@@ -20,7 +21,7 @@ import { warn } from '../output.js';
  *  CRTR_NODE_ID via the canvas data layer), falling back to the process cwd
  *  when not run as a node. */
 export function callerCwd() {
-    const id = process.env['CRTR_NODE_ID'];
+    const id = envNodeId();
     if (id !== undefined && id !== '') {
         const node = getNode(id);
         if (node !== null)

package/dist/core/canvas/meta-file.js

@@ -1,7 +1,8 @@
 // Durable node-meta file primitives shared by normal canvas writes and forward migrations.
 import { randomUUID } from 'node:crypto';
-import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs';
+import { closeSync, existsSync, fsyncSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { withExclusiveDirectoryLock } from '../exclusive-lock.js';
 function parseObject(path, strict) {
     if (!existsSync(path))
         return null;
@@ -36,40 +37,30 @@ export function readMetaObject(path) {
  *  re-entrant — the operation must use {@link writeMetaObjectLocked}, never the
  *  lock-taking {@link writeJsonFileDurably}. */
 export function withMetaLock(path, operation) {
-    const lock = `${path}.lock`;
-    const wait = new Int32Array(new SharedArrayBuffer(4));
-    const deadline = Date.now() + 5_000;
-    for (;;) {
-        try {
-            mkdirSync(lock);
-            break;
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST' || Date.now() >= deadline)
-                throw error;
-            Atomics.wait(wait, 0, 0, 10);
-        }
-    }
-    try {
-        return operation();
-    }
-    finally {
-        rmSync(lock, { recursive: true, force: true });
-    }
+    return withExclusiveDirectoryLock(`${path}.lock`, operation, {
+        timeoutMs: 5_000,
+        timeoutError: () => new Error(`timed out waiting to write node metadata: ${path}`),
+    });
 }
 /** Collision-free durable write (fsync file + parent dir), assuming the caller
  *  already holds {@link withMetaLock} for `path`. */
 export function writeMetaObjectLocked(path, value) {
     const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    const fd = openSync(tmp, 'w');
     try {
-        writeSync(fd, JSON.stringify(value, null, 2));
-        fsyncSync(fd);
+        const fd = openSync(tmp, 'w');
+        try {
+            writeSync(fd, JSON.stringify(value, null, 2));
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(tmp, path);
     }
-    finally {
-        closeSync(fd);
+    catch (error) {
+        rmSync(tmp, { force: true });
+        throw error;
     }
-    renameSync(tmp, path);
     const dirFd = openSync(dirname(path), 'r');
     try {
         fsyncSync(dirFd);

package/dist/core/canvas/migrations.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseSync } from 'node:sqlite';
+/** The ordered migration list. Index `i` is migration version `i + 1`; the db's
+ *  `user_version` tracks how many have been applied. Append only. Journaled
+ *  entries from `src/migrations/registry.ts` follow the local steps, so a new
+ *  registry migration lands as the next version. */
+export declare const MIGRATIONS: ReadonlyArray<(db: DatabaseSync) => void>;
+/** Bring `db` up to the latest schema version. Reads `user_version`, runs each
+ *  pending migration in order, and bumps `user_version` after each so the work
+ *  is gated and idempotent: re-running is a no-op once `user_version` reaches
+ *  `MIGRATIONS.length`. Forward-only.
+ *
+ *  ATOMIC AND RESTARTABLE: each step AND its `user_version` bump run inside one
+ *  `BEGIN IMMEDIATE`/`COMMIT` (SQLite journals `user_version` with the
+ *  transaction, so a rollback restores it too). An interrupted or failing step
+ *  therefore leaves the db exactly at the previous version with none of its
+ *  writes committed — a half-applied step can never wedge every later open. The
+ *  write lock also serializes concurrent openers; the version is re-read after
+ *  acquiring it so a step another process just applied is skipped rather than
+ *  re-run. */
+export declare function migrate(db: DatabaseSync): void;