nervur 0.22.2-4 → 0.22.2-5

package/dist/house/rows.js

@@ -12,6 +12,8 @@ export class Rows {
     #placeNames = new Map();
     /** The last write holding each row, which the next one to hold it waits for. */
     #holds = new Map();
+    // How many times each row's cache has moved, so a read overtaken by a write never lands behind it.
+    #moves = new Map();
     #landed;
     constructor(memory, crypto, tools, names, key) {
         this.#memory = memory;
@@ -33,22 +35,36 @@ export class Rows {
         }
         return place;
     }
+    // A row's cache moved, by a write that landed or one refused: a read in flight across it is behind.
+    #moved(place) {
+        this.#moves.set(place, (this.#moves.get(place) ?? 0) + 1);
+    }
+    #forget(place) {
+        this.#moved(place);
+        this.#held.delete(place);
+    }
     async #read(place) {
-        const cached = this.#held.get(place);
-        if (cached !== undefined)
-            return cached;
-        const { entries, version } = await this.#memory.read({ place });
-        const sealed = entries[ENTRY];
-        let held = { row: null, text: null, version };
-        if (sealed !== undefined) {
-            const opened = await this.#crypto.open(this.#key, sealed.subarray(0, 12), sealed.subarray(12), this.#tools.utf8(place));
-            const text = opened === null ? null : this.#tools.text(opened);
-            if (text === null)
-                throw new Error('a row does not open under these keys');
-            held = { row: JSON.parse(text), text, version };
+        for (;;) {
+            const cached = this.#held.get(place);
+            if (cached !== undefined)
+                return cached;
+            const move = this.#moves.get(place) ?? 0;
+            const { entries, version } = await this.#memory.read({ place });
+            const sealed = entries[ENTRY];
+            let held = { row: null, text: null, version };
+            if (sealed !== undefined) {
+                const opened = await this.#crypto.open(this.#key, sealed.subarray(0, 12), sealed.subarray(12), this.#tools.utf8(place));
+                const text = opened === null ? null : this.#tools.text(opened);
+                if (text === null)
+                    throw new Error('a row does not open under these keys');
+                held = { row: JSON.parse(text), text, version };
+            }
+            // A write that moved the row while this read was in flight wins, and this read looks again.
+            if ((this.#moves.get(place) ?? 0) !== move)
+                continue;
+            this.#held.set(place, held);
+            return held;
         }
-        this.#held.set(place, held);
-        return held;
     }
     /** A row as it stands, or `null`. */
     async get(place) {
@@ -152,10 +168,11 @@ export class Rows {
             }
             if (versions === null) {
                 for (const place of Object.keys(expect))
-                    this.#held.delete(place);
+                    this.#forget(place);
                 return false;
             }
             for (const [place, held] of landed) {
+                this.#moved(place);
                 this.#held.set(place, { ...held, version: versions[place] ?? null });
                 this.#landed?.(place, held.row);
             }

package/dist/node/cli.js

@@ -20,6 +20,7 @@ import { connect } from 'node:net';
 import { basename, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
+import { handAt } from './hand.js';
 import { NodeGround } from './node-ground.js';
 import { notifyReady } from './notify.js';
 const USAGE = 'nervur up <folder> | service <folder> | [--at <socket>] help | ask <house> [--id <being>] [<method> [args]] | <faculty> [<method> [args]]';
@@ -127,7 +128,7 @@ const service = (folder) => {
 };
 const words = process.argv.slice(2);
 // The hand: named, or the one a ground in this folder serves.
-let at = process.env.NERVUR_HAND ?? (existsSync(join('state', 'hand')) ? join('state', 'hand') : undefined);
+let at = process.env.NERVUR_HAND ?? (existsSync(process.platform === 'win32' ? 'state' : join('state', 'hand')) ? handAt('state') : undefined);
 if (words[0] === '--at') {
     at = words[1] ?? fail('--at names no socket');
     words.splice(0, 2);

package/dist/node/file-memory.js

@@ -5,6 +5,7 @@
 import { mkdir, open, readFile, rename } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { syncFolder } from './sync-folder.js';
 const hex = (bytes) => Buffer.from(bytes).toString('hex');
 const unhex = (text) => new Uint8Array(Buffer.from(text, 'hex'));
 export class FileMemory {
@@ -80,12 +81,6 @@ export class FileMemory {
             await file.close();
         }
         await rename(temporary, this.#path);
-        const directory = await open(folder, 'r');
-        try {
-            await directory.sync();
-        }
-        finally {
-            await directory.close();
-        }
+        await syncFolder(folder);
     }
 }

package/dist/node/hand.d.ts

@@ -21,9 +21,16 @@ export interface HandRequest {
     /** The answer the owner holds, which makes a `readOnly` ask a watch. */
     readonly after?: Answer;
 }
+/**
+ * Where a ground's hand stands for its state folder: a socket inside it,
+ * or on Windows a named pipe, which has no place in a folder, named for
+ * the folder's path.
+ */
+export declare const handAt: (state: string, platform?: NodeJS.Platform) => string;
 /**
  * Serves `ask` at `path`: a house's own hand, or a ground's, which also
  * reads `house` and changes its record. A socket left there by a process
- * that is gone is replaced.
+ * that is gone is replaced. A named pipe on Windows is open to its user
+ * alone, as the operating system makes it, and leaves nothing behind.
  */
 export declare const serveHand: (ask: (request: HandRequest) => Promise<unknown>, path: string) => Promise<Hand>;

package/dist/node/hand.js

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
-// The hand on a local socket: one JSON object a line in, one answer a
-// line out, in order. The socket is readable by the ground's user alone.
+// The hand on a local socket, or on Windows a named pipe: one JSON object
+// a line in, one answer a line out, in order. It is open to the ground's
+// user alone.
+import { createHash } from 'node:crypto';
 import { chmod } from 'node:fs/promises';
 import { createServer } from 'node:net';
+import { join, resolve as absolute } from 'node:path';
 import { createInterface } from 'node:readline';
 import { gone } from './gone.js';
 const object = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -46,16 +49,29 @@ const serve = (ask, socket) => {
 // A local socket's path fits the kernel's address: 103 bytes on macOS and
 // the BSDs, 107 on Linux, with the closing zero beyond.
 const LONGEST = process.platform === 'linux' ? 107 : 103;
+const PIPE = /^\\\\[.?]\\pipe\\/;
+/**
+ * Where a ground's hand stands for its state folder: a socket inside it,
+ * or on Windows a named pipe, which has no place in a folder, named for
+ * the folder's path.
+ */
+export const handAt = (state, platform = process.platform) => platform === 'win32' ? `\\\\.\\pipe\\nervur-${createHash('sha256').update(absolute(state).toLowerCase()).digest('hex').slice(0, 16)}` : join(state, 'hand');
 /**
  * Serves `ask` at `path`: a house's own hand, or a ground's, which also
  * reads `house` and changes its record. A socket left there by a process
- * that is gone is replaced.
+ * that is gone is replaced. A named pipe on Windows is open to its user
+ * alone, as the operating system makes it, and leaves nothing behind.
  */
 export const serveHand = async (ask, path) => {
+    if (PIPE.test(path))
+        return listen(ask, path, false);
     const length = Buffer.byteLength(path);
     if (length > LONGEST)
         throw new Error(`a socket's path is at most ${LONGEST} bytes here, and ${path} is ${length}: serve the hand from a shorter folder`);
     await gone(path);
+    return listen(ask, path, true);
+};
+const listen = async (ask, path, file) => {
     const server = createServer((socket) => serve(ask, socket));
     const sockets = new Set();
     server.on('connection', (socket) => {
@@ -64,6 +80,8 @@ export const serveHand = async (ask, path) => {
     });
     await new Promise((resolve, reject) => {
         server.once('error', reject);
+        if (!file)
+            return void server.listen(path, () => resolve());
         // Closed to everyone from the first moment, then opened to the user.
         const mask = process.umask(0o177);
         try {
@@ -73,13 +91,15 @@ export const serveHand = async (ask, path) => {
             process.umask(mask);
         }
     });
-    await chmod(path, 0o600);
+    if (file)
+        await chmod(path, 0o600);
     return {
         close: async () => {
             for (const socket of sockets)
                 socket.destroy();
             await new Promise((resolve) => server.close(() => resolve()));
-            await gone(path);
+            if (file)
+                await gone(path);
         },
     };
 };

package/dist/node/ledger-memory.js

@@ -9,6 +9,7 @@ import { createHash } from 'node:crypto';
 import { mkdir, open, readFile, rename, truncate } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { syncFolder } from './sync-folder.js';
 const GENESIS = { n: 0, hash: '0'.repeat(64) };
 const hash = (text) => createHash('sha256').update(text).digest('hex');
 const unhex = (text) => new Uint8Array(Buffer.from(text, 'hex'));
@@ -103,7 +104,7 @@ export class LedgerMemory {
         const temporary = `${this.#witness}.${process.pid}.tmp`;
         await synced(temporary, 'w', (handle) => handle.writeFile(JSON.stringify(head)));
         await rename(temporary, this.#witness);
-        await synced(dirname(this.#witness), 'r', async () => undefined);
+        await syncFolder(dirname(this.#witness));
     }
     async read({ place }) {
         const held = (await this.#open()).places.get(place);
@@ -135,7 +136,7 @@ export class LedgerMemory {
         try {
             await synced(this.#path, 'a', (handle) => handle.appendFile(`${raw}\n`));
             if (line.n === 1)
-                await synced(dirname(this.#path), 'r', async () => undefined);
+                await syncFolder(dirname(this.#path));
             if (this.#witness !== undefined)
                 await this.#attest(head);
         }

package/dist/node/node-ground.js

@@ -20,7 +20,7 @@ import { WebCarry } from '../bodies/web-carry.js';
 import { Ground } from '../ground/ground.js';
 import { FolderCustody, KeychainCustody } from './custody.js';
 import { FolderClasses } from './folder-classes.js';
-import { serveHand } from './hand.js';
+import { handAt, serveHand } from './hand.js';
 import { serveHttp } from './http.js';
 import { LedgerMemory } from './ledger-memory.js';
 import { takeLock } from './lock.js';
@@ -127,7 +127,7 @@ export class NodeGround {
             // 6. Hook: HTTP chains the web carry and every faculty's handler, and the hand takes its socket.
             if (httpPort !== undefined)
                 http = await serveHttp({ port: httpPort, host: bind }, [web, ...ground.handlers]);
-            const hand = env.NERVUR_HAND ?? join(state, 'hand');
+            const hand = env.NERVUR_HAND ?? handAt(state);
             const served = await serveHand((request) => ground.hand(request), hand);
             return new NodeGround({ ground, hand, tcp, lock, served, http });
         }

package/dist/node/sync-folder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Makes a file's creation or renaming in `folder` durable. On POSIX the
+ * folder is synced. Windows opens no folder for syncing, and NTFS journals
+ * a creation and a rename itself, so there it does nothing.
+ */
+export declare const syncFolder: (folder: string, platform?: NodeJS.Platform) => Promise<void>;

package/dist/node/sync-folder.js

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+import { open } from 'node:fs/promises';
+/**
+ * Makes a file's creation or renaming in `folder` durable. On POSIX the
+ * folder is synced. Windows opens no folder for syncing, and NTFS journals
+ * a creation and a rename itself, so there it does nothing.
+ */
+export const syncFolder = async (folder, platform = process.platform) => {
+    if (platform === 'win32')
+        return;
+    const handle = await open(folder, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.22.2-4",
+  "version": "0.22.2-5",
   "description": "Nervur's kit of Quo: write beings and faculties, and open the house that holds them on any ground.",
   "keywords": [
     "quo",