nervur 0.21.0 → 0.21.2

package/README.md

@@ -212,13 +212,24 @@ catalogue, and the root's asks write the rest: `add` on the catalogue,
 `open`, `host`, `route`, and `boot` on a ward. `host { ward, seed? }`
 stands a ward under a seed you name, or a drawn one.
 
+A ward's place is kept by the root memory unless you name a store.
+`open { key: 'vault', class: 'org.nervur.ground-store' }` opens the
+store every ground ships, and `host { ward, store: 'vault' }` keeps the
+ward there. A class of yours extending `Store` keeps a ward in a bucket
+or a database the same way, and `move { ward, store }` carries a ward
+between keepers whole.
+
 ## What it holds
 
 - **Being, Faculty.** What you extend. A faculty's contract is its class
   and every class between it and `Faculty`.
 - **Entropy, Clock, Custody, Memory, Carrier, Loader.** The contracts a
   terrain fulfils. Each has one suite, and every body that fulfils it
-  passes it.
+  passes it. `nervur/proof` hands you those suites and the unpacking
+  law's as scenes, a title and a function each, so a body of your own,
+  a store in a cloud or a secret of your platform's, runs them under
+  your own runner: `for (const [title, scene] of memoryScenes('Mine',
+  make, expect)) test(title, scene)`. `@nervur-org/s3` is one such body.
 - **Harbor, Terrain, Dock, Catalogue, Registry, WardBeing.** The onion.
 - **World, PointerTerrain** and the pointer bodies, `HeldLoader` among
   them. A whole world with this package alone.
@@ -240,6 +251,8 @@ stands a ward under a seed you name, or a drawn one.
 - **WebDialer, webFaculty**: Quo over the web, a post to `https://` or a
   held line to `wss://`, in any engine with `fetch` and WebSocket.
   `webServe` and `webGround`, from `nervur/http`, listen for it on Node.
+  `answerPost(harbor, listen, request)` answers one post and nothing
+  more, for a function that opens a harbor per request and closes it.
 
 - **The relay**, `org.nervur.relay` and `org.nervur.relay-client`, in
   every harbor: a harbor nobody can dial is reached through one that

package/dist/cli/command.js

@@ -28,7 +28,10 @@
 //                                                   dev, from this folder, at
 //                                                   http://127.0.0.1:P/quo
 //   nervur open   <key> <kind>                      a faculty stands in the box ward
-//   nervur host   <ward> [--seed S]                 a hosted ward stands
+//   nervur host   <ward> [--seed S] [--store K]     a hosted ward stands, kept by the
+//                                                   root memory or the store K
+//   nervur move   <ward> <store | root>             a hosted ward carried to a store,
+//                                                   or back to the root memory
 //   nervur route  <ward pk> <address... | none>     where a ward is reached, in order
 //   nervur reach  <address...>                      where this harbor is reached, as
 //                                                   every invitation it gives says
@@ -59,8 +62,8 @@ import { edgeDev } from './edge.js';
 import { carry, isServed, land, open, pack, request, serve } from './harbor.js';
 // Where `edge dev` answers unless --port names another, wrangler's own.
 const EDGE_PORT = 8787;
-const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--with-seed] [--host H] [--port P]';
-const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'host', 'port']);
+const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|move|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--store K] [--with-seed] [--host H] [--port P]';
+const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'store', 'host', 'port']);
 // The one flag that stands alone, since what it names is a yes.
 const ALONE = 'with-seed';
 export const parse = (argv) => {
@@ -120,7 +123,11 @@ export const requestOf = (command, words, flags) => {
         }
         case 'host': {
             const [ward] = need(1);
-            return { method: 'host', args: { ward: ward, ...(flags.seed === undefined ? {} : { seed: flags.seed }) } };
+            return { method: 'host', args: { ward: ward, ...(flags.seed === undefined ? {} : { seed: flags.seed }), ...(flags.store === undefined ? {} : { store: flags.store }) } };
+        }
+        case 'move': {
+            const [ward, store] = need(2);
+            return { method: 'move', args: { ward: ward, store: store === 'root' ? null : store } };
         }
         case 'route': {
             const [ward, ...where] = words;

package/dist/contract/index.js

@@ -18,7 +18,8 @@ export class Memory {
 export class Custody {
 }
 // Code, by the name a harbor keeps for it, or null where this loader has
-// none. Code never crosses a door and never lives in a cell, so it is the
+// none. Code it has that does not load throws, saying why. Code never
+// crosses a door and never lives in a cell, so it is the
 // one thing beside the seed a terrain hands in: a map, an import, a bundle.
 export class Loader {
 }

package/dist/harbor/catalogue.js

@@ -42,8 +42,14 @@ export class Catalogue extends Faculty {
     // it. The rest stay out, each with its reason.
     async wake() {
         for (const [module, row] of Object.entries(this.#rows)) {
-            const loaded = await this.#harbor.load(row.from).catch(() => null);
-            const refused = loaded === null ? `not found at ${row.from}` : loaded.module !== module ? `${row.from} is module ${loaded.module}` : this.#harbor.check([...this.#running.values(), loaded]);
+            const loaded = await this.#harbor.load(row.from).catch((e) => e);
+            const refused = loaded instanceof Error
+                ? loaded.message
+                : loaded === null
+                    ? `not found at ${row.from}`
+                    : loaded.module !== module
+                        ? `${row.from} is module ${loaded.module}`
+                        : this.#harbor.check([...this.#running.values(), loaded]);
             if (refused === null)
                 this.#running.set(module, loaded);
             else
@@ -54,7 +60,9 @@ export class Catalogue extends Faculty {
     async add(args) {
         if (!text(args.from))
             return { error: 'from is text' };
-        const loaded = await this.#harbor.load(args.from);
+        const loaded = await this.#harbor.load(args.from).catch((e) => e);
+        if (loaded instanceof Error)
+            return { error: loaded.message };
         if (loaded === null)
             return { error: 'no such module' };
         const running = new Map(this.#running);

package/dist/harbor/dock.d.ts

@@ -1,7 +1,9 @@
 import { type Asker, type AskSpec, type Blueprint, 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, seed?: string): Promise<string | null>;
+    host(name: string, invitation: Invitation, seed?: string, store?: string): Promise<string | null>;
+    move(name: string, seed: string, from: string | undefined, to: string | undefined): Promise<string | null>;
+    release(name: string, store: string | undefined): Promise<void>;
     route(pk: string, at: readonly string[] | null): boolean;
     keep(): Promise<boolean>;
     failures(): Failures;
@@ -13,6 +15,7 @@ export interface Hosting {
 export type Hosted = {
     ward: string;
     seed: string;
+    store?: string;
 };
 export type Failures = {
     wards: Record<string, string>;
@@ -41,6 +44,7 @@ export declare class Dock extends WardBeing implements Lender {
     open(args: JsonObject): Promise<JsonObject>;
     sweep(): Promise<JsonObject>;
     host(args: JsonObject): Promise<JsonObject>;
+    move(args: JsonObject): Promise<JsonObject>;
     lend(args: JsonObject): Promise<JsonObject>;
     retract(args: JsonObject): Promise<JsonObject>;
     offer(contract: string): Promise<Invitation | null>;

package/dist/harbor/dock.js

@@ -5,9 +5,14 @@
 //
 //   open    { key, class }      a faculty stands in the box ward, and the
 //                               dock holds a standing on her under her key
-//   host    { ward, seed? }     a hosted ward stands under the seed named,
-//                               or a drawn one, holding a standing on the
-//                               dock; the dock keeps its name and seed
+//   host    { ward, seed?,      a hosted ward stands under the seed named,
+//             store? }          or a drawn one, holding a standing on the
+//                               dock; the dock keeps its name, its seed and
+//                               the store faculty that keeps its place, or
+//                               none for the root memory
+//   move    { ward, store }     a hosted ward's place carried whole to
+//                               another keeper, a store's key or null for
+//                               the root memory, and forgotten where it was
 //   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
@@ -22,6 +27,7 @@
 // route, where the root set none.
 import { Faculty, KIT } from '../being/index.js';
 import { CATALOGUE } from './catalogue.js';
+import { STORE } from './store.js';
 import { readAt, readInvitation } from '../quo/index.js';
 import { ownerAsk, pilots, rootAsk, WardBeing } from '../ward/index.js';
 export const BOX = 'box';
@@ -35,7 +41,8 @@ export class Dock extends WardBeing {
     static asks = {
         ...WardBeing.asks,
         open: ownerAsk('a faculty of this harbor', { required: ['key', 'class'] }),
-        host: ownerAsk('a ward this harbor hosts', { required: ['ward'] }),
+        host: ownerAsk('a ward this harbor hosts, kept by the root memory or by the store named', { required: ['ward'] }),
+        move: ownerAsk('a hosted ward carried to a store, or to the root memory with null', { required: ['ward', 'store'] }),
         route: ownerAsk('where a ward is reached, addresses in order, or null', { required: ['ward', 'at'] }),
         reach: ownerAsk('where this harbor is reached, the addresses every invitation carries', { required: ['at'] }),
         sweep: rootAsk('every place of the memory this harbor does not name, gone'),
@@ -55,7 +62,11 @@ export class Dock extends WardBeing {
         return blueprint;
     }
     get hosted() {
-        return this.cells.hosted.map(({ ward, seed }) => ({ ward, seed }));
+        return this.cells.hosted.map(({ ward, seed, store }) => ({ ward, seed, ...(store === undefined ? {} : { store }) }));
+    }
+    // Whether a key names a store faculty the dock opened.
+    #store(key) {
+        return text(key) && this.#fulfilling(STORE).includes(key);
     }
     get routes() {
         return Object.fromEntries(Object.entries(this.cells.routes).map(([pk, at]) => [pk, [...at]]));
@@ -97,8 +108,11 @@ export class Dock extends WardBeing {
         if ((await this.stance.boot(kind, CATALOGUE, CATALOGUE)) === null || !(await this.#hosting.keep()))
             throw new Error('the catalogue did not stand');
     }
-    // A faculty that goes stops listening first.
+    // A faculty that goes stops listening first, and a store keeping a
+    // ward's place does not go.
     async unboot(args) {
+        if (this.hosted.some((h) => h.store !== undefined && h.store === args.being))
+            return { error: 'a ward is kept by this store' };
         if (typeof args.being === 'string')
             await this.#hosting.lull(args.being);
         return super.unboot(args);
@@ -126,21 +140,60 @@ export class Dock extends WardBeing {
     }
     async host(args) {
         const name = args.ward;
-        if (!text(name) || name === BOX || this.hosted.some((h) => h.ward === name))
-            return { error: 'no such ward to host' };
+        if (!text(name))
+            return { error: 'ward is text' };
+        if (name === BOX)
+            return { error: 'box is the box ward' };
+        if (this.hosted.some((h) => h.ward === name))
+            return { error: `${name} is hosted already` };
         if (args.seed !== undefined && !text(args.seed))
             return { error: 'seed is text' };
+        const store = args.store ?? undefined;
+        if (store !== undefined && !this.#store(store))
+            return { error: 'no such store' };
         const invitation = await this.stance.occupants.invite(name, { hosted: true });
         if (invitation === null)
             return { error: 'not hosted' };
-        const seed = await this.#hosting.host(name, invitation, args.seed);
+        const seed = await this.#hosting.host(name, invitation, args.seed, store);
         if (seed === null) {
             this.stance.occupants.remove(name);
             return { error: 'not hosted' };
         }
-        this.cells.hosted.push({ ward: name, seed });
+        this.cells.hosted.push({ ward: name, seed, ...(store === undefined ? {} : { store }) });
         return { hosted: name };
     }
+    // The place is written where it goes before the dock's cells say so, and
+    // forgotten where it was only once they are kept, so a cut at any step
+    // leaves the ward whole under the keeper the cells name.
+    async move(args) {
+        const rows = this.cells.hosted;
+        const row = rows.find((h) => h.ward === args.ward);
+        if (!row)
+            return { error: 'no such ward' };
+        const to = args.store ?? undefined;
+        if (to !== undefined && !this.#store(to))
+            return { error: 'no such store' };
+        const from = row.store;
+        if (from === to)
+            return { error: `${row.ward} is kept there already` };
+        const refused = await this.#hosting.move(row.ward, row.seed, from, to);
+        if (refused !== null)
+            return { error: refused };
+        const set = (store) => {
+            if (store === undefined)
+                delete row.store;
+            else
+                row.store = store;
+        };
+        set(to);
+        if (!(await this.#hosting.keep())) {
+            set(from);
+            await this.#hosting.move(row.ward, row.seed, to, from);
+            return { error: 'not kept' };
+        }
+        await this.#hosting.release(row.ward, from);
+        return { moved: row.ward, store: to ?? null };
+    }
     async lend(args) {
         if (!text(args.contract))
             return { error: 'contract is text' };

package/dist/harbor/harbor.d.ts

@@ -13,6 +13,8 @@ export declare class Harbor extends Carrier implements Hosting, Cataloguing, Res
     private constructor();
     static open(from?: Terrain | Probing): Promise<Harbor>;
     sweep(): Promise<string[]>;
+    move(name: string, seed: string, from: string | undefined, to: string | undefined): Promise<string | null>;
+    release(name: string, store: string | undefined): Promise<void>;
     failures(): Failures;
     get box(): Ward;
     get dock(): Dock;
@@ -30,7 +32,7 @@ export declare class Harbor extends Carrier implements Hosting, Cataloguing, Res
     run(modules: readonly Loaded[]): string | null;
     stands(kinds: readonly string[]): boolean;
     kindsOf(module: string): string[];
-    host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+    host(name: string, invitation: Invitation, seed?: string, store?: string): Promise<string | null>;
     keep(): Promise<boolean>;
     route(pk: string, at: readonly string[] | null): boolean;
     grounds(kind: string): boolean;

package/dist/harbor/harbor.js

@@ -6,6 +6,7 @@ import { Catalogue, CATALOGUE, catalogueFor } from './catalogue.js';
 import { CarrierFaculty, UNDIALED } from './carrying.js';
 import { BOX, Dock } from './dock.js';
 import { Package } from './package.js';
+import { groundStore, Store } from './store.js';
 import { Registry } from './registry.js';
 import { relayClient, relayFaculty } from './relay.js';
 import { probeGround } from './probe.js';
@@ -22,7 +23,7 @@ export class Harbor extends Carrier {
         super();
         this.terrain = terrain;
         this.#package = pack;
-        const faculties = [...terrain.faculties.map((make) => make(this)), relayFaculty(terrain.clock), relayClient(this, terrain.clock)];
+        const faculties = [...terrain.faculties.map((make) => make(this)), relayFaculty(terrain.clock), relayClient(this, terrain.clock), groundStore(terrain.memory)];
         this.#grounds = new Set(faculties.map((C) => C.kind));
         this.#kit = [catalogueFor(this), Pilot, ...faculties];
         this.#registry = new Registry(this.#kit, []);
@@ -69,7 +70,7 @@ export class Harbor extends Carrier {
         }
         for (const hosted of harbor.dock.hosted) {
             try {
-                await harbor.#unpack(hosted.ward, unhex(hosted.seed));
+                await harbor.#unpack(hosted.ward, unhex(hosted.seed), undefined, undefined, harbor.#keeper(hosted.store));
             }
             catch (e) {
                 harbor.#failed.wards[hosted.ward] = e instanceof Error ? e.message : String(e);
@@ -77,16 +78,81 @@ export class Harbor extends Carrier {
         }
         return harbor;
     }
-    // Hosting: every place of the terrain's memory the dock does not name,
-    // gone. A crash inside `host` leaves such a place, sealed under a seed
-    // nothing kept, and nothing else writes one.
+    // Hosting: every place of the root memory and of each store that the
+    // dock does not name there, gone. A crash inside `host` or `move` leaves
+    // such a place, sealed under a seed nothing kept or kept elsewhere, and
+    // nothing else writes one. A place a store keeps in the root memory is
+    // the store's.
     async sweep() {
-        const mine = new Set(await Promise.all([BOX, ...this.dock.hosted.map((h) => h.ward)].map((name) => this.#package.place(name))));
-        const swept = (await this.terrain.memory.places()).filter((place) => !mine.has(place));
-        for (const place of swept)
+        const named = async (store) => {
+            const wards = this.dock.hosted.filter((h) => h.store === store).map((h) => h.ward);
+            return new Set(await Promise.all((store === undefined ? [BOX, ...wards] : wards).map((name) => this.#package.place(name))));
+        };
+        const stores = this.#stores();
+        const swept = [];
+        const root = await named(undefined);
+        for (const place of await this.terrain.memory.places()) {
+            if (root.has(place) || stores.some(([, s]) => s.occupies(place)))
+                continue;
             await this.terrain.memory.forget(place);
+            swept.push(place);
+        }
+        for (const [key, store] of stores) {
+            const mine = await named(key);
+            for (const place of await store.places()) {
+                if (mine.has(place))
+                    continue;
+                await store.forget(place);
+                swept.push(place);
+            }
+        }
         return swept;
     }
+    // Hosting: a standing ward, carried whole to another keeper. The ward
+    // leaves the harbor's doors while it moves, so no arrival lands on the
+    // keeper it leaves.
+    async move(name, seed, from, to) {
+        const ward = this.#wards.get(name);
+        if (!ward)
+            return 'the ward does not stand';
+        const source = this.#keeper(from);
+        const target = this.#keeper(to);
+        this.#wards.delete(name);
+        try {
+            if (!(await ward.partition.kept()))
+                throw new Error('the ward was not kept');
+            const place = await this.#package.place(name);
+            const entries = new Map(await source.read(place));
+            for (const entry of (await target.read(place)).keys())
+                if (!entries.has(entry))
+                    entries.set(entry, null);
+            await target.write(place, entries);
+            await this.#unpack(name, unhex(seed), undefined, undefined, target);
+            return null;
+        }
+        catch (e) {
+            this.#wards.set(name, ward);
+            return e instanceof Error ? e.message : String(e);
+        }
+    }
+    async release(name, store) {
+        await this.#keeper(store).forget(await this.#package.place(name));
+    }
+    // The root memory, or the store standing under the key named.
+    #keeper(store) {
+        if (store === undefined)
+            return this.terrain.memory;
+        const being = this.box.being(store);
+        if (being instanceof Store)
+            return being;
+        throw new Error(`the store ${store} does not stand`);
+    }
+    #stores() {
+        return Object.keys(this.box.partition.beings).flatMap((key) => {
+            const being = this.box.being(key);
+            return being instanceof Store ? [[key, being]] : [];
+        });
+    }
     // Hosting: what did not stand when the harbor opened, each alone.
     failures() {
         return { wards: { ...this.#failed.wards }, routes: { ...this.#failed.routes } };
@@ -177,14 +243,14 @@ export class Harbor extends Carrier {
     // Hosting: a ward the dock hosts stands now, under the seed named or a
     // drawn one, and the seed it stands under comes back. A ward whose key
     // another ward of this harbor already has does not stand.
-    async host(name, invitation, seed) {
+    async host(name, invitation, seed, store) {
         if (this.#wards.has(name))
             return null;
         const bytes = seed === undefined ? this.terrain.entropy.draw(32) : isHex(seed, 32) ? unhex(seed) : null;
         if (bytes === null || this.holds((await WardKey.from(bytes)).pk))
             return null;
         try {
-            await this.#unpack(name, bytes, invitation);
+            await this.#unpack(name, bytes, invitation, undefined, this.#keeper(store));
         }
         catch {
             return null;
@@ -238,11 +304,11 @@ export class Harbor extends Carrier {
     #dialable(at) {
         return at.some((address) => this.carriers.some((carrier) => carrier.accepts(address)));
     }
-    async #unpack(name, seed, dock, root) {
+    async #unpack(name, seed, dock, root, keeper) {
         const { entropy, clock } = this.terrain;
         const ward = await Ward.unpack({
             seed,
-            memory: await this.#package.rows(name),
+            memory: await this.#package.rows(name, keeper),
             catalogue: this,
             entropy,
             clock,

package/dist/harbor/index.d.ts

@@ -7,4 +7,5 @@ export { readRootRequest, rootLine, type RootRequest } from './root-line.ts';
 export { addGround, grounds, probeGround, type GroundProbe, type Probing } from './probe.ts';
 export { Registry } from './registry.ts';
 export { Push, PUSH, RELAY, RELAY_CLIENT, RELAY_HOLD, RELAY_REST, RELAY_WAIT, RELAYED } from './relay.ts';
+export { GROUND_STORE, groundStore, Store, STORE } from './store.ts';
 export { Terrain, type Opening } from './terrain.ts';

package/dist/harbor/index.js

@@ -10,4 +10,5 @@ export { readRootRequest, rootLine } from './root-line.js';
 export { addGround, grounds, probeGround } from './probe.js';
 export { Registry } from './registry.js';
 export { Push, PUSH, RELAY, RELAY_CLIENT, RELAY_HOLD, RELAY_REST, RELAY_WAIT, RELAYED } from './relay.js';
+export { GROUND_STORE, groundStore, Store, STORE } from './store.js';
 export { Terrain } from './terrain.js';

package/dist/harbor/package.d.ts

@@ -8,6 +8,7 @@ export type Carried = {
 export declare const readCarried: (value: unknown) => Carried | null;
 export declare const carryPlaces: (memory: Memory) => Promise<Carried['places']>;
 export declare const landPlaces: (memory: Memory, carried: Carried) => Promise<string[]>;
+export type Keeper = Pick<Memory, 'read' | 'write' | 'places' | 'forget'>;
 export declare class Package {
     #private;
     readonly memory: Memory;
@@ -16,5 +17,5 @@ export declare class Package {
     static open(memory: Memory, entropy: Entropy, seed: Uint8Array): Promise<Package>;
     derive(info: string[], length: number): Promise<Uint8Array>;
     place(name: string): Promise<string>;
-    rows(name: string): Promise<Rows>;
+    rows(name: string, keeper?: Keeper): Promise<Rows>;
 }

package/dist/harbor/package.js

@@ -99,12 +99,17 @@ class Ward {
     #pack;
     #name;
     #seal;
+    #keeper;
     place;
-    constructor(pack, name, seal, place) {
+    constructor(pack, name, seal, place, keeper) {
         this.#pack = pack;
         this.#name = name;
         this.#seal = seal;
         this.place = place;
+        this.#keeper = keeper;
+    }
+    read() {
+        return this.#keeper.read(this.place);
     }
     entry(row) {
         return this.#pack.derive(['entry', this.#name, row], 16).then(hex);
@@ -123,7 +128,7 @@ class Ward {
         return JSON.parse(new TextDecoder().decode(text));
     }
     write(entries) {
-        return this.#pack.memory.write(this.place, entries);
+        return this.#keeper.write(this.place, entries);
     }
 }
 export class Package {
@@ -145,13 +150,14 @@ export class Package {
     place(name) {
         return this.derive(['place', name], 16).then(hex);
     }
-    // One ward's rows, as the package kept them.
-    async rows(name) {
-        const ward = new Ward(this, name, await this.derive(['seal', name], 32), hex(await this.derive(['place', name], 16)));
+    // One ward's rows, as its keeper kept them: the root memory unless a
+    // store is named.
+    async rows(name, keeper = this.memory) {
+        const ward = new Ward(this, name, await this.derive(['seal', name], 32), await this.place(name), keeper);
         const rows = {};
         const beings = {};
         let any = false;
-        for (const [entry, bytes] of await this.memory.read(ward.place)) {
+        for (const [entry, bytes] of await ward.read()) {
             const { row, value } = await ward.open(entry, bytes);
             any = true;
             if (row === HEAD_ROW)

package/dist/harbor/registry.js

@@ -8,6 +8,7 @@
 //   a class with no kind of its own, or one outside its module's domain
 //   two classes of one kind, or one kind in two modules
 //   a contract with no kind of its own, or one kind for two contracts
+//   a contract of the kit's kinds, save `org.nervur.store`
 //   a kind that is a class and a contract
 //
 // A module's domain is its name's first two segments: `com.acme.shop`
@@ -15,7 +16,11 @@
 // so a faculty fulfils a contract another module declares. Two harbors hold
 // two registries, and nothing between them names a class.
 import { Faculty, isKind, KIT, kindOf } from '../being/index.js';
+import { Store } from './store.js';
 const domainOf = (name) => `${name.split('.').slice(0, 2).join('.')}.`;
+// The kit's contracts a module's class may fulfil: a store keeps a ward's
+// place wherever its author reaches.
+const OPEN = [Store];
 export class Registry {
     #classes = new Map();
     #modules = new Map();
@@ -54,7 +59,7 @@ export class Registry {
                     continue;
                 for (let c = Object.getPrototypeOf(C); c !== Faculty; c = Object.getPrototypeOf(c)) {
                     const contract = kindOf(c);
-                    if (contract.startsWith(KIT))
+                    if (contract.startsWith(KIT) && !OPEN.includes(c))
                         throw new Error(`kind ${contract} is the kit's`);
                     if (contracts.has(contract) && contracts.get(contract) !== c)
                         throw new Error(`two contracts are of kind ${contract}`);

package/dist/harbor/store.d.ts

@@ -0,0 +1,13 @@
+import { Faculty, type BeingClass } from '../being/index.ts';
+import type { Memory } from '../contract/index.ts';
+export declare const STORE = "org.nervur.store";
+export declare const GROUND_STORE = "org.nervur.ground-store";
+export declare abstract class Store extends Faculty {
+    static readonly kind: string;
+    abstract read(place: string): Promise<Map<string, Uint8Array>>;
+    abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+    abstract places(): Promise<string[]>;
+    abstract forget(place: string): Promise<void>;
+    occupies(_place: string): boolean;
+}
+export declare const groundStore: (memory: Memory) => BeingClass;

package/dist/harbor/store.js

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+// The store: a faculty that keeps a hosted ward's place, where the root
+// memory does not. It makes the same promise the Memory body makes, lent
+// once the dock stands: sealed entries in places, each keep whole or not
+// at all. The box ward never moves off the root memory, since the store
+// itself stands from the box ward's cells.
+//
+// A ward is the unit a keeper holds: its head, its ward-being and every
+// being of it are one place and one keep, so an answer's cells and the
+// door's keys move together, whoever keeps them.
+//
+// The kit ships `org.nervur.ground-store` on every ground: places of the
+// terrain's own memory under the faculty's key, so a store stands wherever
+// a harbor does. A store of a cloud, a database or a ledger is a class
+// fulfilling `org.nervur.store`, handed to the catalogue in a module.
+import { Faculty } from '../being/index.js';
+import { hex, utf8 } from '../crypto/index.js';
+export const STORE = 'org.nervur.store';
+export const GROUND_STORE = 'org.nervur.ground-store';
+export class Store extends Faculty {
+    static kind = STORE;
+    // Whether a place of the root memory is this store's own, so the root's
+    // sweep leaves it.
+    occupies(_place) {
+        return false;
+    }
+}
+// A place of the package is thirty-two hex digits.
+const PLACE = 32;
+// The store over the terrain's memory, made for one harbor. Its places are
+// the package's, behind the hex of the faculty's key, so two stores and the
+// root never meet in one place.
+export const groundStore = (memory) => class GroundStore extends Store {
+    static kind = GROUND_STORE;
+    get #prefix() {
+        return hex(utf8(this.stance.key));
+    }
+    occupies(place) {
+        return place.length === this.#prefix.length + PLACE && place.startsWith(this.#prefix);
+    }
+    read(place) {
+        return memory.read(this.#prefix + place);
+    }
+    write(place, entries) {
+        return memory.write(this.#prefix + place, entries);
+    }
+    async places() {
+        return (await memory.places()).filter((place) => this.occupies(place)).map((place) => place.slice(this.#prefix.length));
+    }
+    forget(place) {
+        return memory.forget(this.#prefix + place);
+    }
+};

package/dist/index.d.ts

@@ -3,6 +3,6 @@ export type { Answer, Ask, Asker, AskSpec, BeingClass, BeingLike, Blueprint, Inv
 export { readInvitation } from './quo/index.ts';
 export { Carrier, Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module, type Rows } from './contract/index.ts';
 export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
-export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Terrain, UNDIALED, type Dialed, type Failures, type Ground, type GroundFaculty, type GroundProbe, type Opening, type Probing, type RootRequest, } from './harbor/index.ts';
+export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Store, STORE, Terrain, UNDIALED, type Dialed, type Failures, type Ground, type GroundFaculty, type GroundProbe, type Opening, type Probing, type RootRequest, } from './harbor/index.ts';
 export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';
 export { answerPost, NEUTRAL, WEB, WEB_OPENING, WEB_PUSH, WebDialer, webFaculty, webPush, type WebListen, type WebListener, type WebServe } from './line/index.ts';

package/dist/index.js

@@ -12,7 +12,7 @@ export { Carrier, Clock, Custody, Entropy, Loader, Memory } from './contract/ind
 // Wards and the ward-being.
 export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing } from './ward/index.js';
 // The onion, and the one line its root's asks cross from any front.
-export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Terrain, UNDIALED, } from './harbor/index.js';
+export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Store, STORE, Terrain, UNDIALED, } from './harbor/index.js';
 // The pointer dock: a whole world in one process.
 export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';
 export { answerPost, NEUTRAL, WEB, WEB_OPENING, WEB_PUSH, WebDialer, webFaculty, webPush } from './line/index.js';