nervur 0.23.0 → 0.24.0

package/dist/node/bridge.js

@@ -1,284 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The bridge: a faculty written in any language, as a program the ground
-// starts beside it. It speaks one JSON value a line on its standard
-// streams. Its first answer, to `describe`, is its blueprint and its
-// window, fixed for as long as its faculty stands. It starts with an
-// empty environment beside what `env` names, and it is started again
-// whenever it exits. The object the house holds never changes. It keeps
-// its state in the faculty's memory, through lines of its own.
-//
-//   in   { id, method, args, call }          a call to the program
-//   out  { id, result } | { id, error }      its answer
-//   out  { id, token, args, call }           the program calls a handle
-//   in   { id, result } | { id, error }      the house's answer to that
-//   out  { id, memory, args }                the program reads or writes its memory
-//   in   { id, result } | { id, error }      the ground's answer to that
-//
-// `id` pairs a line with its answer, and a program numbers its own lines.
-// `call` is the call id: the house's on a call in, and the program's own
-// on a call out, the same every time that call is sent, in any life of
-// the program, so a handle called twice acts once. A memory line names
-// `read`, `list` or `write`, with the memory contract's args, every
-// entry's bytes in lowercase hex.
-import { spawn } from 'node:child_process';
-import { accessSync, constants } from 'node:fs';
-import { delimiter, isAbsolute, join } from 'node:path';
-import { createInterface } from 'node:readline';
-import { need } from '../being/need.js';
-import { StrictTools } from '../bodies/strict-tools.js';
-const tools = new StrictTools();
-// The bytes of every entry a memory line writes, read from hex.
-const writesOf = (writes) => {
-    if (typeof writes !== 'object' || writes === null || Array.isArray(writes))
-        throw new TypeError('a write names its places in writes');
-    return Object.fromEntries(Object.entries(writes).map(([place, entries]) => {
-        if (typeof entries !== 'object' || entries === null || Array.isArray(entries))
-            throw new TypeError(`the place ${place} is an object of entries`);
-        return [
-            place,
-            Object.fromEntries(Object.entries(entries).map(([entry, hex]) => {
-                if (hex === null)
-                    return [entry, null];
-                const bytes = typeof hex === 'string' ? tools.bytes(hex) : null;
-                if (bytes === null)
-                    throw new TypeError(`the entry ${entry} of ${place} holds no lowercase hex`);
-                return [entry, bytes];
-            })),
-        ];
-    }));
-};
-const expectOf = (expect) => {
-    if (typeof expect !== 'object' || expect === null || Array.isArray(expect) || !Object.values(expect).every((version) => version === null || typeof version === 'string')) {
-        throw new TypeError('a write names the versions it read in expect');
-    }
-    return expect;
-};
-// One memory line answered from the faculty's memory.
-const remembered = async (memory, op, args) => {
-    if (memory === undefined)
-        return { error: { message: 'this program holds no memory' } };
-    const given = (typeof args === 'object' && args !== null && !Array.isArray(args) ? args : {});
-    try {
-        if (op === 'read') {
-            if (typeof given.place !== 'string')
-                throw new TypeError('a read names its place');
-            const { entries, version } = await memory.read({ place: given.place });
-            return { result: { entries: Object.fromEntries(Object.entries(entries).map(([entry, bytes]) => [entry, tools.hex(bytes)])), version } };
-        }
-        if (op === 'list')
-            return { result: [...(await memory.list())] };
-        if (op === 'write')
-            return { result: (await memory.write({ writes: writesOf(given.writes), expect: expectOf(given.expect) })) };
-        return { error: { message: `no memory line ${op}` } };
-    }
-    catch (error) {
-        return { error: { message: error instanceof Error ? error.message : String(error) } };
-    }
-};
-/** The longest line either side writes, as a Quo frame's bound. */
-const LONGEST = 1_048_576;
-const BACKOFF = 60_000;
-// The contexts of recent calls, where a token the program calls back is sought.
-const CONTEXTS = 32;
-// A name found on the ground's PATH, so the program's own empty environment needs none.
-const located = (command) => {
-    if (isAbsolute(command) || command.includes('/'))
-        return command;
-    for (const dir of (process.env.PATH ?? '').split(delimiter)) {
-        const at = join(dir, command);
-        try {
-            accessSync(at, constants.X_OK);
-            return at;
-        }
-        catch {
-            // Not in this folder.
-        }
-    }
-    throw new Error(`no program ${command} on the ground's PATH`);
-};
-class Bridge {
-    #options;
-    #command;
-    #child;
-    #calls = new Map();
-    #next = 0;
-    #blueprint;
-    #contexts = [];
-    #stopped = false;
-    /** Why it was stopped for good: a program that described another blueprint than it did at the boot. */
-    #refused;
-    #failures = 0;
-    #up;
-    constructor(options) {
-        this.#options = options;
-        this.#command = located(options.command);
-    }
-    // The program started, its describe read, and its blueprint held to the first one.
-    start() {
-        this.#up = (async () => {
-            const child = spawn(this.#command, [...(this.#options.args ?? [])], { cwd: this.#options.cwd, env: { ...this.#options.env }, stdio: ['pipe', 'pipe', 'pipe'] });
-            this.#child = child;
-            child.stdin.on('error', () => undefined);
-            child.stderr.on('data', (chunk) => process.stderr.write(`[${this.#options.command}] ${chunk.toString()}`));
-            const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
-            lines.on('line', (line) => this.#read(line));
-            child.once('exit', () => this.#exited(child));
-            // A program that describes nothing, or runs past the describe's wait, is ended, so its exit starts it again.
-            const failed = (why) => {
-                child.kill('SIGKILL');
-                return new Error(`the program ${this.#options.command} ${why}`);
-            };
-            const described = await this.#send('describe', {}, undefined, this.#options.wait ?? 10_000).catch((error) => {
-                throw failed(`described nothing: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            if ('error' in described)
-                throw failed(`described nothing: ${described.error.message}`);
-            const result = described.result;
-            if (typeof result?.blueprint?.name !== 'string' || typeof result.blueprint.methods !== 'object')
-                throw failed('described no blueprint');
-            const text = JSON.stringify(result.blueprint);
-            // Another blueprint than at the boot is refused and stopped for good: new code arrives when its faculty stands again.
-            if (this.#blueprint !== undefined && this.#blueprint !== text) {
-                this.#stopped = true;
-                this.#refused = `the program ${this.#options.command} describes another blueprint than it did at the boot, and is stopped`;
-                process.stderr.write(`[${this.#options.command}] ${this.#refused}\n`);
-                throw failed('describes another blueprint than it did at the boot');
-            }
-            this.#blueprint = text;
-            this.#failures = 0;
-            return { blueprint: result.blueprint, ...(typeof result.window === 'number' ? { window: result.window } : {}) };
-        })();
-        return this.#up;
-    }
-    #read(line) {
-        if (line.length > LONGEST) {
-            this.#child?.kill('SIGKILL');
-            return;
-        }
-        let message;
-        try {
-            message = JSON.parse(line);
-        }
-        catch {
-            process.stderr.write(`[${this.#options.command}] a line that is no JSON: ${line.slice(0, 200)}\n`);
-            return;
-        }
-        // The program reads or writes its memory.
-        if (typeof message.memory === 'string') {
-            const { id } = message;
-            void remembered(this.#options.memory, message.memory, message.args).then((answer) => this.#write({ id, ...answer }));
-            return;
-        }
-        // The program calls a handle it was handed.
-        if (typeof message.token === 'string') {
-            if (typeof message.call === 'string' && message.call !== '')
-                void this.#callBack(message.id, message.token, message.args, message.call);
-            else
-                this.#write({ id: message.id, error: { message: 'a handle is called with a call id of the program’s own' } });
-            return;
-        }
-        const waiting = typeof message.id === 'number' ? this.#calls.get(message.id) : undefined;
-        if (waiting === undefined)
-            return;
-        this.#calls.delete(message.id);
-        if ('result' in message)
-            waiting.resolve({ result: message.result });
-        else
-            waiting.resolve({ error: { message: typeof message.error?.message === 'string' ? message.error.message : 'the program failed' } });
-    }
-    // A token is answered by the house that handed it, found among the contexts of recent calls.
-    async #callBack(id, token, args, call) {
-        let answer = { error: { message: 'no such token' } };
-        for (const context of [...this.#contexts].reverse()) {
-            answer = await context.call({ token, args: (args ?? {}), id: call });
-            if (!('error' in answer) || answer.error.message !== 'no such token')
-                break;
-        }
-        this.#write({ id, ...answer });
-    }
-    #write(message) {
-        this.#child?.stdin?.write(`${JSON.stringify(message)}\n`);
-    }
-    #send(method, args, call, wait) {
-        const child = this.#child;
-        if (child === undefined || child.exitCode !== null || child.signalCode !== null)
-            return Promise.reject(new Error(`the program ${this.#options.command} is down`));
-        const id = ++this.#next;
-        return new Promise((resolve, reject) => {
-            const timer = wait === undefined ? undefined : setTimeout(() => reject(new Error(`the program ${this.#options.command} did not describe itself in time`)), wait);
-            this.#calls.set(id, {
-                resolve: (answer) => {
-                    clearTimeout(timer);
-                    resolve(answer);
-                },
-                reject: (error) => {
-                    clearTimeout(timer);
-                    reject(error);
-                },
-            });
-            this.#write({ id, method, args, ...(call === undefined ? {} : { call }) });
-        });
-    }
-    // Every call in flight failed, as a crash fails it, and the program started again after a pause that grows.
-    #exited(child) {
-        if (this.#child !== child)
-            return;
-        for (const waiting of this.#calls.values())
-            waiting.reject(new Error(`the program ${this.#options.command} exited`));
-        this.#calls.clear();
-        if (this.#stopped)
-            return;
-        const pause = this.#failures === 0 ? 0 : Math.min(BACKOFF, 1_000 * 2 ** (this.#failures - 1));
-        this.#failures++;
-        setTimeout(() => {
-            if (!this.#stopped)
-                this.start().catch((error) => process.stderr.write(`[${this.#options.command}] ${error instanceof Error ? error.message : String(error)}\n`));
-        }, pause).unref();
-    }
-    /** One call, as the house makes it. A throw is a failure to answer, and the house tries again. */
-    async call(method, args, context) {
-        this.#contexts = [...this.#contexts.filter((held) => held !== context), context].slice(-CONTEXTS);
-        // A program refused for good answers why, which is final: asking again changes nothing until its ground restarts.
-        const refused = () => (this.#refused === undefined ? undefined : { error: { message: this.#refused } });
-        try {
-            await this.#up;
-        }
-        catch (error) {
-            const why = refused();
-            if (why !== undefined)
-                return why;
-            throw error;
-        }
-        return refused() ?? this.#send(method, args, context.id);
-    }
-    async stop() {
-        this.#stopped = true;
-        const child = this.#child;
-        // A program ended by a signal has no exit code, and has exited all the same.
-        if (child === undefined || child.exitCode !== null || child.signalCode !== null)
-            return;
-        const exited = new Promise((resolve) => child.once('exit', () => resolve()));
-        child.stdin?.end();
-        const term = setTimeout(() => child.kill('SIGTERM'), 2_000);
-        const kill = setTimeout(() => child.kill('SIGKILL'), 4_000);
-        await exited;
-        clearTimeout(term);
-        clearTimeout(kill);
-    }
-}
-/**
- * A program in any language, raised as a body: its blueprint and its
- * window from its own `describe`, and an object whose every method is a
- * line to it. It answers once the program has described itself.
- */
-export const bridge = async (options) => {
-    const held = new Bridge(options);
-    // A program that never described itself is offered to no one, so nothing starts it again.
-    const { blueprint, window } = await held.start().catch(async (error) => {
-        await held.stop();
-        throw error;
-    });
-    const { name, methods } = blueprint;
-    const object = Object.fromEntries(Object.keys(methods).map((method) => [method, (args, context) => held.call(method, args, context)]));
-    return { blueprint: need(name, methods), object, ...(window === undefined ? {} : { window }), down: () => held.stop() };
-};

package/dist/node/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/node/cli.js

@@ -1,225 +0,0 @@
-#!/usr/bin/env node
-// SPDX-License-Identifier: Apache-2.0
-// The package's command: a face on a ground's hand, holding no business of
-// its own. Two words start things on this machine; every other word is
-// read from what the running ground describes.
-//
-//   nervur up <folder>                         runs a NodeGround on its folder until it is stopped
-//   nervur service <folder>                    prints its systemd unit, or its launchd job on macOS
-//   nervur help                                what the ground holds: the dock's asks, its faculties, its houses
-//   nervur <word> [<word>] [args]              an ask of the dock, `houses add` asking housesAdd; one word alone, the asks it begins
-//   nervur <faculty> [<method> [args]]         a faculty's method, called through the dock; with none, its methods
-//   nervur ask <house> [--id <being>] [<method> [args]]   an ask of a being; with no method, its describe
-//   nervur ask <house> [--id <being>] --cells            her cells, read and nothing asked
-//   nervur ask dock --id <being> [--cells]               the same of a being of the dock, `faculty.web` or `house.shop`
-//
-// Args are one JSON object, or words `key=value`, each value read as JSON
-// where it reads and as text where it does not, or `-`, one JSON object
-// read from standard input, so no secret stands in a shell's history, or
-// `-- <command> [<arg>...]`, a command line: `nervur shell run -- ls -l`.
-// `--at <socket>` or `NERVUR_HAND` names the hand, and `state/hand` in
-// this folder is it where neither does. `--call <id>` names the ask's call
-// id, so the same ask sent again answers what the first answered. Each
-// prints one JSON value and exits 0 on a result, 1 on an error answered,
-// and 2 where nothing was asked.
-import { existsSync } from 'node:fs';
-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>] [--call <id>] help | ask <house> [--id <being>] [--cells | <method> [args | -]] | <word> [<word>] [args | - | -- <command> [<arg>...]]';
-const fail = (message) => {
-    process.stderr.write(`${message}\n${USAGE}\n`);
-    process.exit(2);
-};
-// One JSON object, or nothing where the text is none.
-const objectOf = (text) => {
-    try {
-        const value = JSON.parse(text);
-        if (typeof value === 'object' && value !== null && !Array.isArray(value))
-            return value;
-    }
-    catch {
-        // No JSON: the caller says why.
-    }
-    return undefined;
-};
-// Standard input, whole.
-const stdin = async () => {
-    let text = '';
-    for await (const chunk of process.stdin)
-        text += String(chunk);
-    return text;
-};
-// Args as one JSON object, as words `key=value`, or as one JSON object on standard input.
-const argsOf = async (words) => {
-    if (words.length === 0)
-        return undefined;
-    if (words.length === 1 && words[0] === '-')
-        return objectOf(await stdin()) ?? fail('standard input holds no JSON object');
-    if (words.length === 1 && words[0].startsWith('{'))
-        return objectOf(words[0]) ?? fail('args are one JSON object');
-    // A command line after `--`, taken whole: its first word the command, and every word after it an arg.
-    if (words[0] === '--')
-        return words.length > 1 ? { command: words[1], args: words.slice(2) } : fail('-- names no command');
-    return Object.fromEntries(words.map((word) => {
-        const at = word.indexOf('=');
-        if (at <= 0)
-            return fail(`${word} is not key=value`);
-        const text = word.slice(at + 1);
-        try {
-            return [word.slice(0, at), JSON.parse(text)];
-        }
-        catch {
-            return [word.slice(0, at), text];
-        }
-    }));
-};
-// One line to the hand, and its answer.
-const exchange = (at, line) => {
-    if (at === undefined || at === '')
-        return fail('no socket: pass --at or set NERVUR_HAND');
-    return new Promise((answered) => {
-        const socket = connect(at);
-        socket.on('error', (error) => fail(`the hand at ${at} does not answer: ${error.message}`));
-        socket.on('connect', () => socket.write(`${JSON.stringify(line)}\n`));
-        createInterface({ input: socket }).once('line', (text) => {
-            socket.end();
-            answered(JSON.parse(text));
-        });
-    });
-};
-// An answer printed. A result and a describe are what was asked; an error answered is the one refusal.
-const print = (answer) => {
-    process.stdout.write(`${JSON.stringify(answer)}\n`);
-    process.exitCode = 'error' in answer ? 1 : 0;
-};
-// One line to the hand, with the call's id where one was named, and its answer printed.
-const send = async (at, line) => print(await exchange(at, { ...line, ...(call === undefined || 'describe' in line ? {} : { call }) }));
-const up = async (folder) => {
-    const ground = await NodeGround.open({ folder }).catch((error) => {
-        process.stderr.write(`the ground did not open: ${error instanceof Error ? error.message : String(error)}\n`);
-        return process.exit(1);
-    });
-    await notifyReady();
-    process.stdout.write(`${JSON.stringify({ hand: ground.hand, houses: ground.ground.list() })}\n`);
-    // A stop is the boot reversed, on an interrupt or on the service manager's SIGTERM.
-    const stop = async () => {
-        await ground.close();
-        process.exit(0);
-    };
-    process.on('SIGINT', stop);
-    process.on('SIGTERM', stop);
-};
-const service = (folder) => {
-    const cli = fileURLToPath(import.meta.url);
-    const unit = process.platform === 'darwin'
-        ? [
-            '<?xml version="1.0" encoding="UTF-8"?>',
-            '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-            '<plist version="1.0">',
-            '<dict>',
-            '  <key>Label</key>',
-            `  <string>org.nervur.${basename(folder).replace(/[^A-Za-z0-9.-]/g, '-')}</string>`,
-            '  <key>ProgramArguments</key>',
-            '  <array>',
-            `    <string>${process.execPath}</string>`,
-            `    <string>${cli}</string>`,
-            '    <string>up</string>',
-            `    <string>${folder}</string>`,
-            '  </array>',
-            '  <key>KeepAlive</key>',
-            '  <true/>',
-            '  <key>RunAtLoad</key>',
-            '  <true/>',
-            '</dict>',
-            '</plist>',
-        ]
-        : [
-            '[Unit]',
-            `Description=A nervur ground on ${folder}`,
-            'After=network-online.target',
-            '',
-            '[Service]',
-            'Type=notify',
-            'NotifyAccess=all',
-            `ExecStart=${process.execPath} ${cli} up ${folder}`,
-            'Restart=always',
-            'RestartSec=1',
-            '',
-            '[Install]',
-            'WantedBy=default.target',
-        ];
-    process.stdout.write(`${unit.join('\n')}\n`);
-};
-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(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);
-}
-// The call's id: the same ask sent again with it answers what the first answered, and runs nothing twice.
-let call;
-if (words[0] === '--call') {
-    call = words[1] ?? fail('--call names no id');
-    words.splice(0, 2);
-}
-const [command, ...rest] = words;
-if (command === undefined)
-    fail('no command');
-else if (command === 'up' || command === 'service') {
-    if (rest.length !== 1)
-        fail(`${command} names one folder`);
-    if (command === 'up')
-        await up(resolve(rest[0]));
-    else
-        service(resolve(rest[0]));
-}
-else if (command === 'help')
-    await send(at, { describe: true });
-else if (command === 'ask') {
-    const [named, ...more] = rest;
-    if (named === undefined)
-        fail('ask names a house');
-    // The dock is the name no house takes: asked by it, the hand reaches the dock's own beings.
-    const house = named === 'dock' ? {} : { house: named };
-    let id;
-    if (more[0] === '--id') {
-        id = more[1] ?? fail('--id names no being');
-        more.splice(0, 2);
-    }
-    if (more[0] === '--cells') {
-        if (more.length > 1)
-            fail('--cells reads her cells alone');
-        await send(at, { ...house, ...(id === undefined ? {} : { id }), cells: true });
-    }
-    else {
-        const [method, ...args] = more;
-        await send(at, { ...house, ...(id === undefined ? {} : { id }), ...(method === undefined ? {} : { method }), ...(args.length === 0 ? {} : { args: await argsOf(args) }) });
-    }
-}
-else {
-    // Every other word is read from what the ground describes: an ask of the dock, as one word or two, or a faculty of its ladder.
-    const described = (await exchange(at, { describe: true })).result;
-    const asks = (described?.dock?.asks ?? []).map(({ method }) => method);
-    const [word, ...more] = rest;
-    const joined = word === undefined ? undefined : `${command}${word[0].toUpperCase()}${word.slice(1)}`;
-    const faculty = described?.faculties?.[command];
-    if (joined !== undefined && asks.includes(joined))
-        await send(at, { method: joined, ...(more.length === 0 ? {} : { args: await argsOf(more) }) });
-    else if (asks.includes(command))
-        await send(at, { method: command, ...(rest.length === 0 ? {} : { args: await argsOf(rest) }) });
-    else if (faculty !== undefined && word === undefined)
-        print({ result: faculty });
-    else if (faculty !== undefined)
-        await send(at, { method: 'callFaculty', args: { faculty: command, method: word, ...(more.length === 0 ? {} : { args: await argsOf(more) }) } });
-    else {
-        // A word the dock's asks begin with shows those asks.
-        const begun = (described?.dock?.asks ?? []).filter(({ method }) => method.startsWith(command) && /^[A-Z]/.test(method.slice(command.length)));
-        print(word === undefined && begun.length > 0 ? { result: begun } : { error: { message: `no ask and no faculty ${command}` } });
-    }
-}

package/dist/node/file-memory.d.ts

@@ -1,13 +0,0 @@
-import type { Memory, PlaceRead } from '../foundation.ts';
-export declare class FileMemory implements Memory {
-    #private;
-    constructor(path: string | URL);
-    read({ place }: {
-        place: string;
-    }): Promise<PlaceRead>;
-    list(): Promise<readonly string[]>;
-    write(options: {
-        writes: Readonly<Record<string, Readonly<Record<string, Uint8Array | null>>>>;
-        expect: Readonly<Record<string, string | null>>;
-    }): Promise<Readonly<Record<string, string | null>> | null>;
-}

package/dist/node/file-memory.js

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Memory in one file, rewritten whole. A write goes to a temporary file,
-// which is synced, renamed over the file, and followed by a sync of its
-// folder, so every place lands together. It suits a small house.
-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 {
-    #path;
-    #stored;
-    #turn = Promise.resolve();
-    constructor(path) {
-        this.#path = typeof path === 'string' ? path : fileURLToPath(path);
-    }
-    #load() {
-        this.#stored ??= readFile(this.#path, 'utf8').then((text) => JSON.parse(text), (error) => {
-            if (error.code === 'ENOENT')
-                return { places: {} };
-            throw error;
-        });
-        return this.#stored;
-    }
-    async read({ place }) {
-        const held = (await this.#load()).places[place];
-        if (held === undefined)
-            return { entries: {}, version: null };
-        return { entries: Object.fromEntries(Object.entries(held.entries).map(([name, text]) => [name, unhex(text)])), version: String(held.version) };
-    }
-    async list() {
-        return Object.keys((await this.#load()).places);
-    }
-    write(options) {
-        const turn = this.#turn.then(() => this.#write(options));
-        this.#turn = turn.catch(() => undefined);
-        return turn;
-    }
-    async #write({ writes, expect, }) {
-        const stored = await this.#load();
-        for (const place of new Set([...Object.keys(writes), ...Object.keys(expect)])) {
-            const held = stored.places[place];
-            if (!(place in expect) || expect[place] !== (held === undefined ? null : String(held.version)))
-                return null;
-        }
-        const next = structuredClone(stored);
-        const versions = {};
-        for (const [place, entries] of Object.entries(writes)) {
-            const held = next.places[place] ?? { version: 0, entries: {} };
-            for (const [name, bytes] of Object.entries(entries)) {
-                if (bytes === null)
-                    delete held.entries[name];
-                else
-                    held.entries[name] = hex(bytes);
-            }
-            held.version++;
-            if (Object.keys(held.entries).length === 0) {
-                delete next.places[place];
-                versions[place] = null;
-            }
-            else {
-                next.places[place] = held;
-                versions[place] = String(held.version);
-            }
-        }
-        await this.#persist(next);
-        this.#stored = Promise.resolve(next);
-        return versions;
-    }
-    async #persist(stored) {
-        const folder = dirname(this.#path);
-        await mkdir(folder, { recursive: true });
-        const temporary = `${this.#path}.${process.pid}.tmp`;
-        const file = await open(temporary, 'w', 0o600);
-        try {
-            await file.writeFile(JSON.stringify(stored));
-            await file.sync();
-        }
-        finally {
-            await file.close();
-        }
-        await rename(temporary, this.#path);
-        await syncFolder(folder);
-    }
-}

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

@@ -1,5 +0,0 @@
-import type { Classes } from '../foundation.ts';
-export declare const FolderClasses: Readonly<{
-    /** The folder's classes, loaded once, or a refusal that says what the folder lacks. */
-    open(dir: string | URL): Promise<Classes>;
-}>;

package/dist/node/folder-classes.js

@@ -1,40 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-// SPDX-License-Identifier: Apache-2.0
-// Classes from a folder the ground names. The folder's entry, `index.js`,
-// `index.mjs` or `index.ts`, exports `steward`, and `public` and `beings`
-// where it has them, as `ClassList` takes them. How code reaches the
-// folder is not the library's: a copy, a checkout, a deploy.
-import { access } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { ClassList } from '../bodies/class-list.js';
-const ENTRIES = ['index.js', 'index.mjs', 'index.ts'];
-export const FolderClasses = Object.freeze({
-    /** The folder's classes, loaded once, or a refusal that says what the folder lacks. */
-    async open(dir) {
-        const folder = resolve(typeof dir === 'string' ? dir : fileURLToPath(dir));
-        let entry;
-        for (const name of ENTRIES) {
-            const at = join(folder, name);
-            if (await access(at).then(() => true, () => false)) {
-                entry = at;
-                break;
-            }
-        }
-        if (entry === undefined)
-            throw new Error(`the folder ${folder} has no ${ENTRIES.join(', ')}`);
-        const module = (await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href)));
-        if (module.steward === undefined)
-            throw new Error(`${entry} exports no steward`);
-        if (module.beings !== undefined && !Array.isArray(module.beings))
-            throw new Error(`${entry} exports beings that are not a list`);
-        return new ClassList({ steward: module.steward, ...(module.public === undefined ? {} : { public: module.public }), ...(module.beings === undefined ? {} : { beings: module.beings }) });
-    },
-});

package/dist/node/gone.d.ts

@@ -1,2 +0,0 @@
-/** Removes a file, and is content where it is already gone. */
-export declare const gone: (path: string) => Promise<void>;

package/dist/node/gone.js

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-import { unlink } from 'node:fs/promises';
-/** Removes a file, and is content where it is already gone. */
-export const gone = (path) => unlink(path).catch((error) => {
-    if (error.code !== 'ENOENT')
-        throw error;
-});