nervur 0.21.4 → 0.22.0

package/src/{ward → core/ward}/stance.ts

@@ -57,7 +57,7 @@ const answerOf = (read: Read): Answer => {
   return readValue(read.object, DEPTH) ?? silence;
 };
 
-export class WardStance implements Stance {
+export class HouseStance implements Stance {
   readonly key: string;
   readonly occupants: Occupants;
   readonly standings: Standings;
@@ -66,7 +66,10 @@ export class WardStance implements Stance {
   readonly #lanes = new Lanes();
   readonly #cells = new Cells(() => this.#told());
 
-  constructor(inside: Inside, key: string, row: BeingRow) {
+  // `carries` is what every stance of the house holds beside her own, for
+  // the class born of it.
+  constructor(inside: Inside, key: string, row: BeingRow, carries: Readonly<Record<string, unknown>> = {}) {
+    Object.assign(this, carries);
     this.key = key;
     this.#inside = inside;
     this.#row = row;

package/src/core/ward/ward.ts

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+// The ward: the contract of the being that stewards one Quo ward through
+// its house, the first being of every ward. Her asks are the root's, shown
+// and answered to whoever pilots. The core names no class of it. Her class
+// is her row's kind, and `become` names another.
+//
+// Every ward also holds far beings as their owner, each under a name: `hold`
+// takes an owner invitation on any being of any harbor, `pilot` asks it, and
+// `drop` lets it go. A held being is an ordinary standing of the ward's,
+// under `held:<name>`, kept in her partition, so it moves its keys and
+// survives a restart as every relation does.
+import { Being, isSilence, isWord, kindOf, OWNER, shipped, ships, told, type Answer, type Asker, type AskSpec, type BeingClass, type Blueprint, type Invitation, type JsonObject, type Stance } from '../being/index.ts';
+import { readInvitation } from '../quo/index.ts';
+
+// What the house lends its ward, and no other being.
+export interface Steward {
+  pk(): string;
+  classOf(name: string, registry?: string): BeingClass | undefined;
+  beings(): Record<string, { class: string; registry?: string; public: boolean; absent: boolean }>;
+  // A new being, her class resolved through the registry named, or the
+  // house's own.
+  boot(key: string, className: string, registry?: string): Promise<'booted' | 'key taken' | 'no such class' | 'threw at birth'>;
+  // A being her row names, stood where she does not stand yet, in a house
+  // whose beings stand: the box ward's faculties.
+  stand(key: string): 'booted' | 'stands' | 'no such being' | 'no such class' | 'threw at birth';
+  unboot(key: string): boolean;
+  publish(key: string | null): boolean;
+  invite(being: string, id: string, notes: JsonObject): Promise<Invitation | null>;
+  ask(being: string | null, method: string | undefined, args: JsonObject): Promise<Answer>;
+  // The ward born again of the class of this kind, on her stance, resolved
+  // through the registry named or the house's own: null, or why not.
+  become(kind: string, registry?: string): string | null;
+}
+
+export type WardStance = Stance & { readonly steward: Steward };
+
+// Whoever pilots a ward: the root, holding its unsealed ask, or an owner,
+// an occupant of the ward the root invited as one.
+export const pilots = (asker: Asker, notes: JsonObject | undefined): boolean => asker.id === OWNER || notes?.owner === true;
+
+// An ask whoever pilots the ward may make.
+export const ownerAsk = (description: string, input: JsonObject = {}): AskSpec => ({ description, input: { type: 'object', ...input }, for: pilots });
+
+// An ask the root alone may make, so a carried key pilots but never hands
+// piloting on.
+export const rootAsk = (description: string, input: JsonObject = {}): AskSpec => ({ description, input: { type: 'object', ...input }, for: (asker: Asker) => asker.id === OWNER });
+
+// The standing a far being held under a name is kept under. No other
+// standing of a ward takes this prefix: the dock's are her faculties' keys
+// and a hosted ward's is `dock`, and a take under an id already held is
+// refused, so a collision is refused and never overwrites.
+export const HELD = 'held:';
+
+const text = (v: unknown): v is string => typeof v === 'string';
+const object = (v: unknown): v is JsonObject => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+export abstract class Ward extends Being {
+  static override readonly kind: string = 'org.nervur.ward';
+  static {
+    ships(this);
+  }
+  static override asks: Record<string, AskSpec> = {
+    boot: ownerAsk('a new being of this ward', { required: ['key', 'class'] }),
+    unboot: ownerAsk('a being out, with every relation she holds', { required: ['being'] }),
+    public: ownerAsk('the being a stranger reaches, or none', { required: ['key'] }),
+    invite: ownerAsk('an invitation on a being of this ward', { required: ['being', 'id'] }),
+    ask: ownerAsk('a being of this ward, asked as the owner; with no being, the public being asked as nobody'),
+    own: rootAsk('an invitation for an owner of this ward, under an id', { required: ['id'] }),
+    disown: rootAsk('an owner no more', { required: ['id'] }),
+    become: ownerAsk('this ward born again of the class of a kind, her cells and relations kept', { required: ['class'] }),
+    hold: ownerAsk('an owner invitation on a far being, held under a name from now on', { required: ['name', 'invitation'] }),
+    pilot: ownerAsk('the far being held under a name, asked as its owner', { required: ['name'] }),
+    drop: ownerAsk('the far being held under a name, let go', { required: ['name'] }),
+  };
+
+  readonly steward: Steward;
+
+  // A ward is born of her stance alone, and a ward's stance carries her
+  // steward.
+  constructor(stance: Stance) {
+    super(stance);
+    this.steward = (stance as WardStance).steward;
+  }
+
+  // Whether a class fulfils this contract: this class, or one below it.
+  static fulfils(C: unknown): C is BeingClass {
+    return typeof C === 'function' && C.prototype instanceof this;
+  }
+
+  become(args: JsonObject): JsonObject {
+    if (!text(args.class)) return { error: 'class is text' };
+    const refused = this.steward.become(args.class);
+    return refused === null ? { became: args.class } : { error: refused };
+  }
+
+  override describe(asker: Asker): Blueprint {
+    const { asks } = super.describe(asker);
+    return { asks, notes: pilots(asker, this.notes(asker)) ? { pk: this.steward.pk(), class: kindOf(this.constructor), beings: this.steward.beings() } : {} };
+  }
+
+  async own(args: JsonObject): Promise<JsonObject> {
+    if (!text(args.id)) return { error: 'id is text' };
+    return (await this.stance.occupants.invite(args.id, { owner: true })) ?? { error: 'id taken' };
+  }
+
+  disown(args: JsonObject): JsonObject {
+    if (!text(args.id) || this.stance.occupants.notes(args.id)?.owner !== true) return { error: 'no such owner' };
+    this.stance.occupants.remove(args.id);
+    return { disowned: args.id };
+  }
+
+  async boot(args: JsonObject): Promise<JsonObject> {
+    if (!text(args.key) || !text(args.class)) return { error: 'key and class are text' };
+    if (shipped(this.steward.classOf(args.class))) return { error: 'no such class' };
+    const out = await this.steward.boot(args.key, args.class);
+    return out === 'booted' ? { booted: args.key } : { error: out };
+  }
+
+  unboot(args: JsonObject): JsonObject | Promise<JsonObject> {
+    return text(args.being) && this.steward.unboot(args.being) ? { unbooted: args.being } : { error: 'no such being' };
+  }
+
+  public(args: JsonObject): JsonObject {
+    if (args.key !== null && !text(args.key)) return { error: 'key is text or null' };
+    return this.steward.publish(args.key) ? { public: args.key } : { error: 'no such being' };
+  }
+
+  async invite(args: JsonObject): Promise<JsonObject> {
+    if (!text(args.being) || !text(args.id) || (args.notes !== undefined && !object(args.notes))) return { error: 'being and id are text, notes an object' };
+    const invitation = await this.steward.invite(args.being, args.id, args.notes ?? {});
+    return invitation ?? { error: 'not invited' };
+  }
+
+  async ask(args: JsonObject): Promise<JsonObject> {
+    if ((args.being !== undefined && !text(args.being)) || (args.method !== undefined && !text(args.method)) || (args.args !== undefined && !object(args.args))) {
+      return { error: 'being and method are text, args an object' };
+    }
+    const out = await this.steward.ask(args.being ?? null, args.method, args.args ?? {});
+    if (isSilence(out)) return { error: 'silence' };
+    if (isWord(out)) return { error: told(out) as string };
+    return { answer: out };
+  }
+
+  async hold(args: JsonObject): Promise<JsonObject> {
+    if (!text(args.name)) return { error: 'name is text' };
+    const invitation = readInvitation(args.invitation);
+    if (invitation === null) return { error: 'no invitation' };
+    if (this.stance.standings.get(HELD + args.name)) return { error: `${args.name} is held` };
+    return (await this.stance.standings.take(HELD + args.name, invitation)) === null ? { error: 'not taken' } : { held: args.name, ward: invitation.ward };
+  }
+
+  async pilot(args: JsonObject): Promise<JsonObject> {
+    if (!text(args.name) || (args.method !== undefined && !text(args.method)) || (args.args !== undefined && !object(args.args))) return { error: 'name and method are text, args an object' };
+    const standing = this.stance.standings.get(HELD + args.name);
+    if (!standing) return { error: `${args.name} is not held` };
+    const out = await standing.ask(args.method, args.args ?? {});
+    if (isSilence(out)) return { error: 'silence' };
+    if (isWord(out)) return { error: told(out) as string };
+    return { answer: out };
+  }
+
+  drop(args: JsonObject): JsonObject {
+    if (!text(args.name)) return { error: 'name is text' };
+    return this.stance.standings.remove(HELD + args.name) ? { dropped: args.name } : { error: `${args.name} is not held` };
+  }
+}

package/src/core.ts

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// The core as a stranger's code reads it: every export of the kit that is
+// no default. It names no platform, so it runs wherever JavaScript runs.
+// `kit.ts` joins it with the defaults; the core's own suites bind it with
+// classes written for them, so a module they load reads the core alone.
+
+// Beings, faculties, and what they are told.
+export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './core/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 './core/being/index.ts';
+export { readInvitation } from './core/quo/index.ts';
+
+// What a terrain gives a harbor.
+export { Carrier, Clock, Custody, Entropy, Loader, Memory, type Bundled, type Module, type Rows } from './core/contract/index.ts';
+
+// Wards and the ward.
+export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, Ward, type Steward, type WardStance } from './core/ward/index.ts';
+
+// The onion, and the one line its root's asks cross from any front.
+export {
+  BOX,
+  CarrierFaculty,
+  Catalogue,
+  copyPackage,
+  Dock,
+  Harbor,
+  addGround,
+  groundOf,
+  grounds,
+  readRootRequest,
+  Registry,
+  REGISTRY,
+  RegistryFaculty,
+  MemoryFaculty,
+  MEMORY,
+  Terrain,
+  UNDIALED,
+  type Defaults,
+  type Dialed,
+  type Failures,
+  type Ground,
+  type GroundProbe,
+  type Probing,
+  type RootRequest,
+  type Sockets,
+  type TcpListening,
+  type WebListen,
+  type WebListener,
+  type WebServe,
+} from './core/harbor/index.ts';
+
+// The pointer dock: a whole world in one process, and the loaders of code.
+export { BundleLoader, CryptoEntropy, HeldCustody, SourceLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts, type WorldParts } from './core/pointer/index.ts';
+export { answerPost } from './core/line/answer.ts';
+export { NEUTRAL } from './core/line/ground.ts';
+export { WebDialer } from './core/line/index.ts';

package/src/defaults/dock/index.ts

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+// The default dock: the `Dock` contract as it stands, for an owner who
+// writes no dock of her own.
+import { ships } from '../../core/being/index.ts';
+import { Dock } from '../../core/harbor/index.ts';
+
+export class DefaultDock extends Dock {
+  static override readonly kind: string = 'org.nervur.default-dock';
+  static {
+    ships(this);
+  }
+}

package/src/defaults/index.ts

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+// The defaults: beings and faculties an owner gets where she writes none of
+// her own, one folder each. Each extends a contract of the core, the core
+// names none, and none names a platform: what a carrier needs of one, its
+// terrain hands it.
+export { DefaultDock } from './dock/index.ts';
+export { GroundMemory } from './memory/index.ts';
+export { TcpFaculty } from './tcp/index.ts';
+export { DefaultWard } from './ward/index.ts';
+export { WebFaculty } from './web/index.ts';

package/src/defaults/memory/index.ts

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// The default memory faculty: places of the terrain's own memory under the
+// faculty's key, so a memory faculty stands wherever a harbor does. Its
+// places are the package's, behind the hex of the faculty's key, so two
+// memory faculties and the root never meet in one place.
+import { ships, type Stance } from '../../core/being/index.ts';
+import type { Memory } from '../../core/contract/index.ts';
+import { hex, utf8 } from '../../core/crypto/index.ts';
+import { groundOf, MemoryFaculty } from '../../core/harbor/index.ts';
+
+// A place of the package is thirty-two hex digits.
+const PLACE = 32;
+
+export class GroundMemory extends MemoryFaculty {
+  static override readonly kind: string = 'org.nervur.ground-memory';
+  static {
+    ships(this);
+  }
+
+  readonly #memory: Memory;
+
+  constructor(stance: Stance) {
+    super(stance);
+    this.#memory = groundOf(stance).terrain.memory;
+  }
+
+  get #prefix(): string {
+    return hex(utf8(this.stance.key));
+  }
+
+  override occupies(place: string): boolean {
+    return place.length === this.#prefix.length + PLACE && place.startsWith(this.#prefix);
+  }
+
+  read(place: string): Promise<Map<string, Uint8Array>> {
+    return this.#memory.read(this.#prefix + place);
+  }
+
+  write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void> {
+    return this.#memory.write(this.#prefix + place, entries);
+  }
+
+  async places(): Promise<string[]> {
+    return (await this.#memory.places()).filter((place) => this.occupies(place)).map((place) => place.slice(this.#prefix.length));
+  }
+
+  forget(place: string): Promise<void> {
+    return this.#memory.forget(this.#prefix + place);
+  }
+}

package/src/defaults/tcp/index.ts

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+// Quo over TCP as a carrier faculty. It dials every `tcp://` address the
+// harbor routes, and listens where its cells say, handing what it hears to
+// its ground, on the sockets its terrain hands it:
+//
+//   listen  { host?, port? }   listen there from now on, 127.0.0.1 and a
+//                              free port unless named, and on every wake
+//                              at the port it bound
+//   deaf                       listen nowhere from now on
+import { ships, type AskSpec, type JsonObject, type Stance } from '../../core/being/index.ts';
+import { CarrierFaculty, groundOf, type Dialed, type Sockets, type TcpListening } from '../../core/harbor/index.ts';
+import { tcpAddress } from '../../core/quo/index.ts';
+import { ownerAsk } from '../../core/ward/index.ts';
+
+type Listen = { host: string; port: number };
+const listenOf = (value: unknown): Listen | null => {
+  if (typeof value !== 'object' || value === null) return null;
+  const { host, port } = value as Record<string, unknown>;
+  return typeof host === 'string' && Number.isInteger(port) && (port as number) >= 0 && (port as number) <= 65_535 ? { host, port: port as number } : null;
+};
+
+export class TcpFaculty extends CarrierFaculty {
+  static override readonly kind: string = 'org.nervur.tcp';
+  static override readonly carries: string = 'tcp';
+  static {
+    ships(this);
+  }
+  static override asks: Record<string, AskSpec> = {
+    listen: ownerAsk('listen for Quo over TCP, and on every wake', { properties: { host: { type: 'string' }, port: { type: 'integer' } } }),
+    deaf: ownerAsk('listen nowhere'),
+  };
+
+  readonly #sockets: Sockets;
+  #listener: TcpListening | undefined;
+
+  // A ground with no sockets speaks no TCP, and no TCP faculty stands on it.
+  constructor(stance: Stance) {
+    super(stance);
+    const sockets = groundOf(stance).terrain.tcp;
+    if (!sockets) throw new Error('this ground speaks no TCP');
+    this.#sockets = sockets();
+  }
+
+  accepts(address: string): boolean {
+    return tcpAddress(address) !== null;
+  }
+
+  dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
+    return this.#sockets.dial(address, pk, bytes);
+  }
+
+  override listening(): string[] {
+    return this.#listener ? [this.#listener.at] : [];
+  }
+
+  override async awake(): Promise<void> {
+    const at = listenOf(this.cells.listen);
+    if (at && !this.#listener) this.#listener = await this.#sockets.listen(groundOf(this.stance), at.host, at.port);
+  }
+
+  override async sleep(): Promise<void> {
+    await this.#sockets.close();
+    await this.#listener?.close();
+    this.#listener = undefined;
+  }
+
+  async listen(args: JsonObject): Promise<JsonObject> {
+    const at = listenOf({ host: args.host ?? '127.0.0.1', port: args.port ?? 0 });
+    if (at === null) return { error: 'host is text and port a port' };
+    await this.#listener?.close();
+    this.#listener = undefined;
+    try {
+      this.#listener = await this.#sockets.listen(groundOf(this.stance), at.host, at.port);
+    } catch (e) {
+      return { error: (e as Error).message };
+    }
+    // The port it bound, so a wake listens where every route and every
+    // invitation already points.
+    this.cells.listen = { host: at.host, port: tcpAddress(this.#listener.at)!.port };
+    return { at: this.#listener.at };
+  }
+
+  async deaf(): Promise<JsonObject> {
+    await this.#listener?.close();
+    this.#listener = undefined;
+    delete this.cells.listen;
+    return { deaf: true };
+  }
+}

package/src/defaults/ward/index.ts

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+// The default ward: the `Ward` contract as it stands, for a hosted ward
+// whose owner names no class of her own.
+import { ships } from '../../core/being/index.ts';
+import { Ward } from '../../core/ward/index.ts';
+
+export class DefaultWard extends Ward {
+  static override readonly kind: string = 'org.nervur.default-ward';
+  static {
+    ships(this);
+  }
+}

package/src/defaults/web/index.ts

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+// Quo over the web as a carrier faculty. It dials every `http`, `https`,
+// `ws` and `wss` address the harbor routes, on fetch and the WebSocket
+// client, and listens where its cells say through the listener its
+// terrain runs, where the terrain runs one:
+//
+//   listen  { host?, port?, path?, origins? }
+//                  listen there from now on, 127.0.0.1, a free port, `/`
+//                  and every origin unless named, and on every wake at the
+//                  port it bound
+//   deaf           listen nowhere from now on
+import { ships, type AskSpec, type JsonObject } from '../../core/being/index.ts';
+import { CarrierFaculty, groundOf, type Dialed, type Ground, type WebListen, type WebListener } from '../../core/harbor/index.ts';
+import { WebDialer } from '../../core/line/index.ts';
+import { webAddress } from '../../core/quo/index.ts';
+import { ownerAsk } from '../../core/ward/index.ts';
+
+const listenOf = (value: unknown): WebListen | null => {
+  if (typeof value !== 'object' || value === null) return null;
+  const { host, port, path, origins } = value as Record<string, unknown>;
+  const fine =
+    typeof host === 'string' &&
+    Number.isInteger(port) &&
+    (port as number) >= 0 &&
+    (port as number) <= 65_535 &&
+    typeof path === 'string' &&
+    path.startsWith('/') &&
+    Array.isArray(origins) &&
+    origins.every((o) => typeof o === 'string');
+  return fine ? { host, port: port as number, path, origins: origins as string[] } : null;
+};
+
+export class WebFaculty extends CarrierFaculty {
+  static override readonly kind: string = 'org.nervur.web';
+  static override readonly carries: string = 'web';
+  static {
+    ships(this);
+  }
+  static override asks: Record<string, AskSpec> = {
+    listen: ownerAsk('listen for Quo over the web, and on every wake'),
+    deaf: ownerAsk('listen nowhere'),
+  };
+
+  readonly #dialer = new WebDialer();
+  #listener: WebListener | undefined;
+
+  get #ground(): Ground {
+    return groundOf(this.stance);
+  }
+
+  accepts(address: string): boolean {
+    return webAddress(address) !== null;
+  }
+
+  dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
+    return this.#dialer.dial(address, pk, bytes);
+  }
+
+  override listening(): string[] {
+    return this.#listener ? [...this.#listener.at] : [];
+  }
+
+  override async awake(): Promise<void> {
+    const at = listenOf(this.cells.listen);
+    const serve = this.#ground.terrain.web;
+    if (at && serve && !this.#listener) this.#listener = await serve(this.#ground, at);
+  }
+
+  override async sleep(): Promise<void> {
+    await this.#dialer.close();
+    await this.#listener?.close();
+    this.#listener = undefined;
+  }
+
+  async listen(args: JsonObject): Promise<JsonObject> {
+    const serve = this.#ground.terrain.web;
+    if (!serve) return { error: 'this ground listens nowhere on the web' };
+    const at = listenOf({ host: args.host ?? '127.0.0.1', port: args.port ?? 0, path: args.path ?? '/', origins: args.origins ?? ['*'] });
+    if (at === null) return { error: 'host is text, port a port, path a path and origins a list' };
+    await this.#listener?.close();
+    this.#listener = undefined;
+    try {
+      this.#listener = await serve(this.#ground, at);
+    } catch (e) {
+      return { error: (e as Error).message };
+    }
+    this.cells.listen = { ...at, port: this.#listener.port };
+    return { at: [...this.#listener.at] };
+  }
+
+  async deaf(): Promise<JsonObject> {
+    await this.#listener?.close();
+    this.#listener = undefined;
+    delete this.cells.listen;
+    return { deaf: true };
+  }
+}

package/src/edge.ts

@@ -2,9 +2,10 @@
 // `nervur` as a Workers bundle reads it: the main entry, with the edge
 // ground added, so `Harbor.open({ given: { state, env } })` in a Durable
 // Object keeps a harbor in its storage.
-import { edgeGround } from './edge/index.ts';
-import { addGround } from './harbor/index.ts';
+import { edgeGround } from './core/edge/index.ts';
+import { addGround } from './core/harbor/index.ts';
+import { DEFAULTS } from './index.ts';
 
 export * from './index.ts';
 
-addGround(edgeGround);
+addGround(edgeGround, DEFAULTS);

package/src/index.ts

@@ -1,55 +1,18 @@
 // 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`. Node reads
-// `node.ts` under this name instead, which adds the Node ground.
-import { addGround } from './harbor/index.ts';
-import { neutralGround } from './line/index.ts';
+// `nervur`: what a stranger writes a world with, the kit of `kit.ts`. It
+// imports no platform, so it runs wherever JavaScript runs. A disk is
+// `nervur/folder`. Node reads `node.ts` under this name instead, which
+// adds the Node ground. It binds the kit, so wherever a ground stands, a
+// module's `'nervur'` is this copy's.
+import { bindKit } from './core/contract/index.ts';
+import { addGround } from './core/harbor/index.ts';
+import { neutralGround } from './core/line/index.ts';
+import * as kit from './kit.ts';
+import { DEFAULTS } from './kit.ts';
 
-// Beings, faculties, and what they are told.
-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 * from './kit.ts';
 
-// What a terrain gives a harbor.
-export { Carrier, Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module, type Rows } from './contract/index.ts';
-
-// Wards and the ward-being.
-export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
-
-// 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,
-  Store,
-  STORE,
-  Terrain,
-  UNDIALED,
-  type Dialed,
-  type Failures,
-  type Ground,
-  type GroundFaculty,
-  type GroundProbe,
-  type Opening,
-  type Probing,
-  type RootRequest,
-} from './harbor/index.ts';
-
-// The pointer dock: a whole world in one process.
-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';
+bindKit(kit);
 
 // The ground that fits everywhere, tried after any a platform entry adds.
-addGround(neutralGround);
+addGround(neutralGround, DEFAULTS);

package/src/kit.ts

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// The kit a stranger writes a world with, and what a module's `'nervur'`
+// reads: the core of `core.ts` and the defaults joined. It names no
+// platform, so it runs wherever JavaScript runs. The main entry binds it as
+// the kit a loader links a module against, so every ground and the command
+// bind it.
+import { DefaultDock, DefaultWard, GroundMemory, TcpFaculty, WebFaculty } from './defaults/index.ts';
+import type { Defaults } from './core/harbor/index.ts';
+
+export * from './core.ts';
+
+// The defaults: the beings and faculties a harbor runs where its owner
+// writes none, and the list every ground runs them from.
+export { DefaultDock, DefaultWard, GroundMemory, TcpFaculty, WebFaculty } from './defaults/index.ts';
+export const DEFAULTS: Defaults = { dock: DefaultDock, ward: DefaultWard, classes: [GroundMemory, TcpFaculty, WebFaculty] };

package/src/node.ts

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // `nervur` as Node reads it: the main entry, with the Node ground added, so
 // `Harbor.open()` keeps a harbor in a folder and serves its root line.
-import { addGround } from './harbor/index.ts';
-import { nodeGround } from './node/index.ts';
+import { addGround } from './core/harbor/index.ts';
+import { nodeGround } from './core/node/index.ts';
+import { DEFAULTS } from './index.ts';
 
 export * from './index.ts';
 
-addGround(nodeGround);
+addGround(nodeGround, DEFAULTS);

package/dist/cli/harbor.d.ts

@@ -1,16 +0,0 @@
-import type { JsonObject } from '../being/index.ts';
-import { Harbor, type Carried, type RootRequest } from '../harbor/index.ts';
-export declare const open: (dir: string) => Promise<Harbor>;
-export declare const isServed: (dir: string) => Promise<boolean>;
-export declare const request: (dir: string, req: RootRequest) => Promise<JsonObject>;
-export declare const carry: (dir: string, seed: boolean) => Promise<Carried>;
-export declare const pack: (dir: string, file: string, name: string, secret: string | undefined) => Promise<JsonObject>;
-export declare const land: (dir: string, value: unknown) => Promise<string[]>;
-export type Served = {
-    pk: string;
-    at: string;
-    listening: string[];
-    root: string;
-    close(): Promise<void>;
-};
-export declare const serve: (dir: string, host?: string, port?: number) => Promise<Served>;