nervur 0.19.2 → 0.20.0

package/dist/crypto/subtle.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+// Web Crypto, read at every use. A page on a plain http origin has `crypto`
+// without `subtle`, and a terrain may install it after this module loads.
+export const subtle = () => {
+    const found = globalThis.crypto?.subtle;
+    if (!found)
+        throw new Error('this terrain has no crypto.subtle: a ward needs a secure context');
+    return found;
+};
+// Web Crypto takes a buffer it owns, so every input is copied into one.
+export const own = (bytes) => Uint8Array.from(bytes);
+// The PKCS#8 wrapping of a thirty-two byte secret, which is the whole of it
+// for both curves.
+const PKCS8 = { Ed25519: '302e020100300506032b657004220420', X25519: '302e020100300506032b656e04220420' };
+export const importSecret = (curve, secret, uses) => {
+    if (secret.length !== 32)
+        throw new TypeError('a secret is thirty-two bytes');
+    const prefix = Uint8Array.from(PKCS8[curve].match(/../g), (b) => parseInt(b, 16));
+    const wrapped = new Uint8Array(48);
+    wrapped.set(prefix);
+    wrapped.set(secret, 16);
+    return subtle().importKey('pkcs8', wrapped, { name: curve }, true, uses);
+};
+// Web Crypto gives a private key's public half only through a JWK.
+export const publicOf = async (key) => {
+    const { x } = await subtle().exportKey('jwk', key);
+    const binary = atob(x.replaceAll('-', '+').replaceAll('_', '/'));
+    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+};

package/dist/crypto/x25519.d.ts

@@ -0,0 +1,2 @@
+export declare const x25519Public: (secret: Uint8Array) => Promise<Uint8Array>;
+export declare const agree: (secret: Uint8Array, pk: Uint8Array) => Promise<Uint8Array | null>;

package/dist/crypto/x25519.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+// X25519 agrees. A secret is thirty-two bytes, clamped by the function and
+// never before.
+import { zero } from './bytes.js';
+import { importSecret, own, publicOf, subtle } from './subtle.js';
+export const x25519Public = async (secret) => publicOf(await importSecret('X25519', secret, ['deriveBits']));
+// The agreement, or null for a public key that takes no seal: one whose
+// agreement is thirty-two zero bytes, or one the terrain refuses to read.
+export const agree = async (secret, pk) => {
+    if (pk.length !== 32)
+        return null;
+    try {
+        const mine = await importSecret('X25519', secret, ['deriveBits']);
+        const theirs = await subtle().importKey('raw', own(pk), { name: 'X25519' }, false, []);
+        const shared = new Uint8Array(await subtle().deriveBits({ name: 'X25519', public: theirs }, mine, 256));
+        return zero(shared) ? null : shared;
+    }
+    catch {
+        return null;
+    }
+};

package/dist/folder/index.d.ts

@@ -0,0 +1,13 @@
+import { Custody, Memory, type Entropy, type Rows } from '../contract/index.ts';
+export declare const folderName: (name: string) => string;
+export declare class FolderMemory extends Memory {
+    readonly root: string;
+    constructor(root: string);
+    open(name: string): Promise<Rows>;
+}
+export declare class FolderCustody extends Custody {
+    #private;
+    readonly root: string;
+    constructor(root: string, entropy: Entropy);
+    seed(name: string): Promise<Uint8Array>;
+}

package/dist/folder/index.js

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: Apache-2.0
+// A harbor on a disk, for local proof: `nervur/folder`, the one entry that
+// names a platform.
+//
+//   <root>/<ward>/seed               the ward's seed, as hex
+//   <root>/<ward>/ward.json          the ward's head
+//   <root>/<ward>/<key>/being.json   one being: class, cells, relations
+//
+// A folder name is the ward's name or the being's key, escaped, so no name
+// reaches outside its folder. A file is written whole, beside itself and
+// then renamed over, so a crash leaves the last kept copy. Seeds are plain
+// files: custody that seals them is a terrain's, in the dock.
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { hex, isHex, unhex } from '../crypto/index.js';
+import { Custody, Memory } from '../contract/index.js';
+import { HEAD_ROW } from '../ward/index.js';
+const HEAD = 'ward.json';
+const BEING = 'being.json';
+export const folderName = (name) => encodeURIComponent(name).replaceAll('.', '%2E').replaceAll('*', '%2A') || '%';
+const nameOf = (folder) => (folder === '%' ? '' : decodeURIComponent(folder));
+const missing = (e) => e.code === 'ENOENT';
+const readJson = async (path) => {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (e) {
+        if (missing(e))
+            return undefined;
+        throw e;
+    }
+};
+const writeWhole = async (path, text) => {
+    await writeFile(`${path}.next`, text, { mode: 0o600 });
+    await rename(`${path}.next`, path);
+};
+class FolderRows {
+    rows;
+    #dir;
+    #told = new Set();
+    #line = Promise.resolve(true);
+    constructor(dir, rows) {
+        this.#dir = dir;
+        this.rows = rows;
+    }
+    told(row) {
+        this.#told.add(row);
+    }
+    // Every row told since the last keep, written in order, one keep at a time.
+    kept() {
+        const rows = [...this.#told];
+        this.#told.clear();
+        this.#line = this.#line.then(() => this.#write(rows)).catch(() => false);
+        return this.#line;
+    }
+    async #write(told) {
+        await mkdir(this.#dir, { recursive: true, mode: 0o700 });
+        const beings = (this.rows.beings ?? {});
+        for (const row of told) {
+            if (row === HEAD_ROW) {
+                await writeWhole(join(this.#dir, HEAD), JSON.stringify(this.rows.ward ?? null));
+                continue;
+            }
+            const dir = join(this.#dir, folderName(row));
+            if (!Object.hasOwn(beings, row)) {
+                await rm(dir, { recursive: true, force: true });
+                continue;
+            }
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            await writeWhole(join(dir, BEING), JSON.stringify(beings[row]));
+        }
+        return true;
+    }
+}
+export class FolderMemory extends Memory {
+    root;
+    constructor(root) {
+        super();
+        this.root = root;
+    }
+    // The rows as the disk holds them now.
+    async open(name) {
+        const dir = join(this.root, folderName(name));
+        const rows = {};
+        const head = await readJson(join(dir, HEAD));
+        if (head !== undefined)
+            rows.ward = head;
+        const beings = {};
+        const entries = await readdir(dir, { withFileTypes: true }).catch((e) => (missing(e) ? [] : Promise.reject(e)));
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const row = await readJson(join(dir, entry.name, BEING));
+            if (row !== undefined)
+                beings[nameOf(entry.name)] = row;
+        }
+        if (head !== undefined || Object.keys(beings).length > 0)
+            rows.beings = beings;
+        return new FolderRows(dir, rows);
+    }
+}
+export class FolderCustody extends Custody {
+    root;
+    #entropy;
+    constructor(root, entropy) {
+        super();
+        this.root = root;
+        this.#entropy = entropy;
+    }
+    async seed(name) {
+        const dir = join(this.root, folderName(name));
+        const path = join(dir, 'seed');
+        const kept = await readFile(path, 'utf8').catch((e) => (missing(e) ? undefined : Promise.reject(e)));
+        if (kept !== undefined) {
+            const text = kept.trim();
+            if (!isHex(text, 32))
+                throw new Error(`${path} is not a seed`);
+            return unhex(text);
+        }
+        const seed = this.#entropy.draw(32);
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        await writeFile(path, `${hex(seed)}\n`, { mode: 0o600, flag: 'wx' });
+        return seed;
+    }
+}

package/dist/harbor/dock.d.ts

@@ -0,0 +1,19 @@
+import { type AskSpec, type Invitation, type JsonObject } from '../being/index.ts';
+import { WardBeing, type Lender, type WardBeingStance } from '../ward/index.ts';
+export interface Hosting {
+    host(name: string, invitation: Invitation): Promise<boolean>;
+}
+export declare const BOX = "box";
+export declare class Dock extends WardBeing implements Lender {
+    #private;
+    static cells: JsonObject;
+    static asks: Record<string, AskSpec>;
+    constructor(stance: WardBeingStance, hosting: Hosting);
+    get hosted(): string[];
+    open(args: JsonObject): Promise<JsonObject>;
+    host(args: JsonObject): Promise<JsonObject>;
+    lend(args: JsonObject): Promise<JsonObject>;
+    retract(args: JsonObject): Promise<JsonObject>;
+    offer(contract: string): Promise<Invitation | null>;
+    withdraw(contract: string, heir: string): Promise<void>;
+}

package/dist/harbor/dock.js

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: Apache-2.0
+// The dock: the box ward's ward-being. Beside the root's asks of every ward,
+// she opens faculties, hosts wards, and lends each contract a faculty
+// fulfils to the wards she hosts.
+//
+//   open    { key, class }      a faculty stands in the box ward, and the
+//                               dock holds a standing on her under her key
+//   host    { ward }            a hosted ward stands, holding a standing on
+//                               the dock
+//   lend    { contract }        asked by a hosted ward: an offer from a
+//                               faculty that fulfils the contract
+//   retract { contract, heir }  an offer that was not taken
+import { Faculty } from '../being/index.js';
+import { readInvitation } from '../quo/index.js';
+import { ownerAsk, WardBeing } from '../ward/index.js';
+export const BOX = 'box';
+const text = (v) => typeof v === 'string';
+const hosted = (_, notes) => notes?.hosted === true;
+export class Dock extends WardBeing {
+    static cells = { hosted: [] };
+    static asks = {
+        ...WardBeing.asks,
+        open: ownerAsk('a faculty of this harbor', { required: ['key', 'class'] }),
+        host: ownerAsk('a ward this harbor hosts', { required: ['ward'] }),
+        lend: { description: 'an offer from a faculty fulfilling a contract', input: { type: 'object', required: ['contract'] }, for: hosted },
+        retract: { description: 'an offer that was not taken', input: { type: 'object', required: ['contract', 'heir'] }, for: hosted },
+    };
+    #hosting;
+    constructor(stance, hosting) {
+        super(stance);
+        this.#hosting = hosting;
+    }
+    get hosted() {
+        return [...this.cells.hosted];
+    }
+    async open(args) {
+        if (!text(args.key) || !text(args.class))
+            return { error: 'key and class are text' };
+        if (!Faculty.fulfils(this.steward.classOf(args.class)))
+            return { error: 'no such faculty' };
+        const opened = await this.stance.boot(args.class, args.key, args.key);
+        return opened === null ? { error: 'not opened' } : { opened };
+    }
+    async host(args) {
+        const name = args.ward;
+        if (!text(name) || name === BOX || this.hosted.includes(name))
+            return { error: 'no such ward to host' };
+        const invitation = await this.stance.occupants.invite(name, { hosted: true });
+        if (invitation === null)
+            return { error: 'not hosted' };
+        if (!(await this.#hosting.host(name, invitation))) {
+            this.stance.occupants.remove(name);
+            return { error: 'not hosted' };
+        }
+        this.cells.hosted.push(name);
+        return { hosted: name };
+    }
+    async lend(args) {
+        if (!text(args.contract))
+            return { error: 'contract is text' };
+        const invitation = await this.offer(args.contract);
+        return invitation ? { invitation } : { error: 'nothing lent' };
+    }
+    async retract(args) {
+        if (!text(args.contract) || !text(args.heir))
+            return { error: 'contract and heir are text' };
+        await this.withdraw(args.contract, args.heir);
+        return { retracted: args.heir };
+    }
+    // Lender: the first standing faculty that fulfils the contract offers.
+    async offer(contract) {
+        for (const key of this.#fulfilling(contract)) {
+            const out = await this.stance.standings.get(key)?.ask('offer');
+            const invitation = readInvitation(out?.invitation);
+            if (invitation)
+                return invitation;
+        }
+        return null;
+    }
+    async withdraw(contract, heir) {
+        for (const key of this.#fulfilling(contract))
+            await this.stance.standings.get(key)?.ask('retract', { heir });
+    }
+    #fulfilling(contract) {
+        const beings = this.steward.beings();
+        return this.stance.standings.ids().filter((key) => {
+            const being = beings[key];
+            const C = being && !being.absent ? this.steward.classOf(being.class) : undefined;
+            return Faculty.fulfils(C) && Faculty.contracts(C).includes(contract);
+        });
+    }
+}

package/dist/harbor/harbor.d.ts

@@ -0,0 +1,22 @@
+import type { Answer, BeingClass, Invitation, JsonObject } from '../being/index.ts';
+import { Carrier } from '../contract/index.ts';
+import { Ward } from '../ward/index.ts';
+import { Dock, type Hosting } from './dock.ts';
+import { Registry } from './registry.ts';
+import type { Terrain } from './terrain.ts';
+export declare class Harbor extends Carrier implements Hosting {
+    #private;
+    readonly terrain: Terrain;
+    readonly registry: Registry;
+    private constructor();
+    static open(terrain: Terrain, classes: readonly BeingClass[]): Promise<Harbor>;
+    get box(): Ward;
+    get dock(): Dock;
+    ward(name: string): Ward | undefined;
+    get names(): string[];
+    root(method?: string, args?: JsonObject): Promise<Answer>;
+    holds(pk: string): boolean;
+    arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    host(name: string, invitation: Invitation): Promise<boolean>;
+}

package/dist/harbor/harbor.js

@@ -0,0 +1,84 @@
+import { Carrier } from '../contract/index.js';
+import { DOCK, Ward } from '../ward/index.js';
+import { BOX, Dock } from './dock.js';
+import { Registry } from './registry.js';
+export class Harbor extends Carrier {
+    terrain;
+    registry;
+    #wards = new Map();
+    constructor(terrain, registry) {
+        super();
+        this.terrain = terrain;
+        this.registry = registry;
+    }
+    static async open(terrain, classes) {
+        const harbor = new Harbor(terrain, new Registry(classes));
+        await harbor.#unpack(BOX, undefined, (stance) => new Dock(stance, harbor));
+        for (const name of harbor.dock.hosted)
+            await harbor.#unpack(name);
+        return harbor;
+    }
+    get box() {
+        return this.#wards.get(BOX);
+    }
+    get dock() {
+        return this.box.wardBeing;
+    }
+    ward(name) {
+        return this.#wards.get(name);
+    }
+    get names() {
+        return [...this.#wards.keys()].filter((name) => name !== BOX);
+    }
+    // The unsealed ask on the box ward: what a command line carries.
+    root(method, args) {
+        return this.box.root(method, args);
+    }
+    holds(pk) {
+        return this.#door(pk) !== undefined;
+    }
+    // Bytes for one of this harbor's doors, or nothing.
+    async arrive(pk, bytes) {
+        const ward = this.#door(pk);
+        return ward ? (await ward.door.arrive(bytes)).bytes : null;
+    }
+    // Carrier: this harbor's own doors first, then the terrain's.
+    carry(pk, bytes) {
+        return this.holds(pk) ? this.arrive(pk, bytes) : this.terrain.carrier.carry(pk, bytes);
+    }
+    // Hosting: a ward the dock hosts stands now.
+    async host(name, invitation) {
+        if (this.#wards.has(name))
+            return false;
+        try {
+            await this.#unpack(name, invitation);
+        }
+        catch {
+            return false;
+        }
+        if (this.#wards.get(name).wardBeing.stance.standings.get(DOCK))
+            return true;
+        this.#wards.delete(name);
+        return false;
+    }
+    async #unpack(name, dock, root) {
+        const { entropy, clock, custody, memory } = this.terrain;
+        const ward = await Ward.unpack({
+            seed: await custody.seed(name),
+            memory: await memory.open(name),
+            catalogue: this.registry,
+            entropy,
+            clock,
+            carrier: this,
+            ...(dock ? { dock } : {}),
+            ...(root ? { root } : {}),
+        });
+        this.#wards.set(name, ward);
+    }
+    #door(pk) {
+        for (const ward of this.#wards.values())
+            if (ward.pk === pk)
+                return ward;
+        return undefined;
+    }
+}

package/dist/harbor/index.d.ts

@@ -1,10 +1,4 @@
-export { MemoryHarbor, type Booted, type WardFactory } from './memory.ts';
-export { Harbor, DEFAULT_CODE, type Hosted, type Bound, type Loader } from './core.ts';
-export { dial, type Dialer } from './dial.ts';
-export { MemoryStore, values, rowsOf, type Store, type Kept, type WardRecord } from './store.ts';
-export { HEAD, fromRows, rowsIn } from '../ward/partition.ts';
-export { request, Socket, SUITE, REFUSED, type Reach, type Carry, type Line, type Announce } from './reach.ts';
-export type { Ground, WardPointers, Memory } from '../ward/ground.ts';
-export { BOX, OFFER, RETRACT, volatile } from '../ward/ground.ts';
-export { Box, BOX_SEED, BOX_ASKS, stand, hold, offerTo, roll } from './box.ts';
-export { maker, entropy, learnPk } from '../ward/ground.ts';
+export { BOX, Dock, type Hosting } from './dock.ts';
+export { Harbor } from './harbor.ts';
+export { Registry } from './registry.ts';
+export { Terrain } from './terrain.ts';

package/dist/harbor/index.js

@@ -1,19 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
-// nervur/harbor — the Ground contract and the harbors. The only
-// place in the package that may know a wire, and it knows one on the
-// standard surface alone: fetch and WebSocket. MemoryHarbor knows none: it
-// is one process talking to itself, where every ward assertion is made.
-export { MemoryHarbor } from './memory.js';
-export { Harbor, DEFAULT_CODE } from './core.js';
-export { dial } from './dial.js';
-export { MemoryStore, values, rowsOf } from './store.js';
-// What a store keeping a ward in rows needs: the name of the row that is not
-// a being, and the partition back from the rows it was cut into.
-export { HEAD, fromRows, rowsIn } from '../ward/partition.js';
-export { request, Socket, SUITE, REFUSED } from './reach.js';
-export { BOX, OFFER, RETRACT, volatile } from '../ward/ground.js';
-// The box as one being, and the acts a harbor runs to stand it.
-export { Box, BOX_SEED, BOX_ASKS, stand, hold, offerTo, roll } from './box.js';
-// What a harbor builds a ground out of. Convenience, never contract: a kit
-// writing its own harbor may write these three again.
-export { maker, entropy, learnPk } from '../ward/ground.js';
+// The onion: a terrain, a registry, the dock, and the harbor.
+export { BOX, Dock } from './dock.js';
+export { Harbor } from './harbor.js';
+export { Registry } from './registry.js';
+export { Terrain } from './terrain.js';

package/dist/harbor/registry.d.ts

@@ -0,0 +1,7 @@
+import type { BeingClass } from '../being/index.ts';
+import type { Catalogue } from '../ward/index.ts';
+export declare class Registry implements Catalogue {
+    #private;
+    constructor(classes: readonly BeingClass[]);
+    classOf(name: string): BeingClass | undefined;
+}

package/dist/harbor/registry.js

@@ -0,0 +1,13 @@
+export class Registry {
+    #classes = new Map();
+    constructor(classes) {
+        for (const C of classes) {
+            if (this.#classes.has(C.name) && this.#classes.get(C.name) !== C)
+                throw new Error(`two classes are named ${C.name}`);
+            this.#classes.set(C.name, C);
+        }
+    }
+    classOf(name) {
+        return this.#classes.get(name);
+    }
+}

package/dist/harbor/terrain.d.ts

@@ -0,0 +1,8 @@
+import type { Carrier, Clock, Custody, Entropy, Memory } from '../contract/index.ts';
+export declare abstract class Terrain {
+    abstract readonly entropy: Entropy;
+    abstract readonly clock: Clock;
+    abstract readonly custody: Custody;
+    abstract readonly memory: Memory;
+    abstract readonly carrier: Carrier;
+}

package/dist/harbor/terrain.js

@@ -0,0 +1,2 @@
+export class Terrain {
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.ts';
+export type { Answer, Ask, Asker, AskSpec, BeingClass, BeingLike, Blueprint, Invitation, Json, JsonObject, Occupants, Reply, Schema, Silence, Stance, Standing, Standings, Wanted, Word, WordName } from './being/index.ts';
+export { readInvitation } from './quo/index.ts';
+export { Carrier, Clock, Custody, Entropy, Memory, type Rows } from './contract/index.ts';
+export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
+export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.ts';
+export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';

package/dist/index.js

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// `nervur`: what a stranger writes a world with. It imports no platform, so
+// it runs wherever JavaScript runs. A disk is `nervur/folder`.
+// Beings, faculties, and what they are told.
+export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.js';
+export { readInvitation } from './quo/index.js';
+// What a terrain gives a harbor.
+export { Carrier, Clock, Custody, Entropy, Memory } from './contract/index.js';
+// Wards and the ward-being.
+export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing } from './ward/index.js';
+// The onion.
+export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.js';
+// The pointer dock: a whole world in one process.
+export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';

package/dist/pointer/bodies.d.ts

@@ -0,0 +1,20 @@
+import { Clock, Custody, Entropy, Memory, type Rows } from '../contract/index.ts';
+export declare class CryptoEntropy extends Entropy {
+    draw(length: number): Uint8Array;
+}
+export declare class SystemClock extends Clock {
+    now(): number;
+    wait(ms: number): {
+        done: Promise<void>;
+        cancel(): void;
+    };
+}
+export declare class HeldCustody extends Custody {
+    #private;
+    constructor(entropy: Entropy);
+    seed(name: string): Promise<Uint8Array>;
+}
+export declare class VolatileMemory extends Memory {
+    #private;
+    open(name: string): Promise<Rows>;
+}

package/dist/pointer/bodies.js

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// The pointer terrain's bodies: each contract fulfilled in one process,
+// with nothing beyond JavaScript.
+import { Clock, Custody, Entropy, Memory } from '../contract/index.js';
+export class CryptoEntropy extends Entropy {
+    draw(length) {
+        return globalThis.crypto.getRandomValues(new Uint8Array(length));
+    }
+}
+export class SystemClock extends Clock {
+    now() {
+        return Date.now();
+    }
+    wait(ms) {
+        let timer;
+        const done = new Promise((resolve) => (timer = setTimeout(resolve, ms)));
+        return { done, cancel: () => clearTimeout(timer) };
+    }
+}
+// Seeds drawn once per name and held by this object.
+export class HeldCustody extends Custody {
+    #entropy;
+    #seeds = new Map();
+    constructor(entropy) {
+        super();
+        this.#entropy = entropy;
+    }
+    seed(name) {
+        let seed = this.#seeds.get(name);
+        if (!seed)
+            this.#seeds.set(name, (seed = this.#entropy.draw(32)));
+        return Promise.resolve(seed);
+    }
+}
+// Rows that live as long as this object: opening a name again gives the
+// same rows, which is what a restart in one process finds.
+export class VolatileMemory extends Memory {
+    #wards = new Map();
+    open(name) {
+        let rows = this.#wards.get(name);
+        if (!rows)
+            this.#wards.set(name, (rows = { rows: {}, told: () => { }, kept: () => Promise.resolve(true) }));
+        return Promise.resolve(rows);
+    }
+}

package/dist/pointer/index.d.ts

@@ -0,0 +1,2 @@
+export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.ts';
+export { NoCarrier, PointerCarrier, PointerTerrain, World, type PointerParts } from './world.ts';

package/dist/pointer/index.js

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
+// The pointer dock: a whole world with `nervur` alone.
+export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.js';
+export { NoCarrier, PointerCarrier, PointerTerrain, World } from './world.js';

package/dist/pointer/world.d.ts

@@ -0,0 +1,34 @@
+import type { BeingClass } from '../being/index.ts';
+import { Carrier, type Clock, type Custody, type Entropy, type Memory } from '../contract/index.ts';
+import { Harbor, Terrain } from '../harbor/index.ts';
+export declare class NoCarrier extends Carrier {
+    carry(): Promise<Uint8Array | null>;
+}
+export declare class PointerCarrier extends Carrier {
+    #private;
+    constructor(world: World);
+    carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+}
+export type PointerParts = {
+    entropy?: Entropy;
+    clock?: Clock;
+    custody?: Custody;
+    memory?: Memory;
+    carrier?: Carrier;
+};
+export declare class PointerTerrain extends Terrain {
+    readonly entropy: Entropy;
+    readonly clock: Clock;
+    readonly custody: Custody;
+    readonly memory: Memory;
+    readonly carrier: Carrier;
+    constructor(parts?: PointerParts);
+}
+export declare class World {
+    #private;
+    readonly cut: Set<string>;
+    harbor(name: string, classes: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    get(name: string): Harbor;
+    restart(name: string, classes?: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+}