nervur 0.22.0 → 0.22.2-3

package/src/core/line/web.ts

@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Quo over the web, `quo/CARRIER-WEB.md`, on what every engine has: fetch
-// and the WebSocket client.
-//
-//   WebDialer     bytes to a ward pk at an address: `http` and `https` as
-//                 one post each, `ws` and `wss` on one held line per
-//                 address, which many asks share
-//
-// A post that comes back with status 200 and a body is a reply, and every
-// other status is nothing. A post the network refused, or a held line
-// that did not open, was not dialed. A line that carried a box and closed
-// answers nothing.
-import { concat, hex, isHex, unhex } from '../crypto/index.ts';
-import { UNDIALED, type Dialed } from '../harbor/index.ts';
-import { webAddress, type WebAddress } from '../quo/index.ts';
-import { askBody, readBody } from './frame.ts';
-
-export const MIN_POST = 65;
-export const MAX_POST = 64 + 1_048_576;
-const MAX_ID = 0xffff_ffff;
-
-// Bytes on a buffer of their own, as a body and a message take them.
-const own = (bytes: Uint8Array): Uint8Array<ArrayBuffer> => new Uint8Array(bytes);
-
-// One held line to one address.
-class HeldLine {
-  readonly #socket: WebSocket;
-  readonly #waiting = new Map<number, (box: Uint8Array | null) => void>();
-  #next = 1;
-
-  private constructor(socket: WebSocket) {
-    this.#socket = socket;
-    socket.binaryType = 'arraybuffer';
-    socket.addEventListener('message', (e: MessageEvent) => {
-      const frame = typeof e.data === 'string' ? null : readBody(new Uint8Array(e.data as ArrayBuffer));
-      if (frame === null) return this.close();
-      if (frame.kind === 'ask') return;
-      const done = this.#waiting.get(frame.id);
-      this.#waiting.delete(frame.id);
-      done?.(frame.kind === 'reply' ? frame.box : null);
-    });
-    socket.addEventListener('close', () => {
-      for (const done of this.#waiting.values()) done(null);
-      this.#waiting.clear();
-    });
-  }
-
-  // A line that opened with the subprotocol `quo`, or null.
-  static open(href: string, onClose: () => void): Promise<HeldLine | null> {
-    return new Promise((resolve) => {
-      let socket: WebSocket;
-      try {
-        socket = new WebSocket(href, 'quo');
-      } catch {
-        resolve(null);
-        return;
-      }
-      const line = new HeldLine(socket);
-      socket.addEventListener('open', () => (socket.protocol === 'quo' ? resolve(line) : (socket.close(), resolve(null))));
-      socket.addEventListener('close', () => {
-        onClose();
-        resolve(null);
-      });
-      socket.addEventListener('error', () => resolve(null));
-    });
-  }
-
-  ask(pk: Uint8Array, box: Uint8Array): Promise<Uint8Array | null> {
-    if (this.#socket.readyState !== WebSocket.OPEN) return Promise.resolve(null);
-    const id = this.#next;
-    this.#next = this.#next === MAX_ID ? 1 : this.#next + 1;
-    return new Promise((resolve) => {
-      this.#waiting.set(id, resolve);
-      this.#socket.send(own(askBody(id, pk, box)));
-    });
-  }
-
-  close(): void {
-    this.#socket.close();
-  }
-}
-
-export class WebDialer {
-  readonly #lines = new Map<string, Promise<HeldLine | null>>();
-
-  dial(at: string, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    const address = webAddress(at);
-    if (address === null || !isHex(pk, 64)) return Promise.resolve(UNDIALED);
-    return address.held ? this.#held(address, pk, bytes) : this.#post(address, pk, bytes);
-  }
-
-  async #post(address: WebAddress, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    let response: Response;
-    try {
-      response = await fetch(address.href, { method: 'POST', body: own(concat(unhex(pk), bytes)) });
-    } catch {
-      return UNDIALED;
-    }
-    const body = new Uint8Array(await response.arrayBuffer().catch(() => new ArrayBuffer(0)));
-    return response.status === 200 && body.length > 0 ? body : null;
-  }
-
-  async #held(address: WebAddress, pk: string, bytes: Uint8Array): Promise<Dialed> {
-    let line = this.#lines.get(address.href);
-    if (!line) {
-      line = HeldLine.open(address.href, () => this.#lines.delete(address.href));
-      this.#lines.set(address.href, line);
-      void line.then((held) => held ?? this.#lines.delete(address.href));
-    }
-    const held = await line;
-    return held ? held.ask(unhex(pk), bytes) : UNDIALED;
-  }
-
-  async close(): Promise<void> {
-    const lines = [...this.#lines.values()];
-    this.#lines.clear();
-    for (const line of await Promise.all(lines)) line?.close();
-  }
-}
-
-// The ward pk and box a post carries, or null for a body that is no ask.
-export const readPost = (body: Uint8Array): { pk: string; box: Uint8Array } | null =>
-  body.length < MIN_POST || body.length > MAX_POST ? null : { pk: hex(body.subarray(0, 64)), box: body.slice(64) };

package/src/core/node/index.ts

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/node`: the Node ground. A harbor keeps its seed and sealed
-// memory in a folder, its DNA among it, runs a module's source by
-// importing it, hands its carriers Node's sockets and HTTP server, and
-// serves the root line on a local
-// socket, so the `nervur` command reaches it while it stands.
-//
-//   <dir>/seed        the harbor's seed
-//   <dir>/<place>/    its sealed memory
-//   <dir>/root.sock   the root line while the harbor is served, open to
-//                     this user alone, or in the temporary folder for a
-//                     folder too deep for a socket path
-//
-// One run holds a folder: a terrain refuses a folder another run serves.
-import { createHash } from 'node:crypto';
-import { chmod, rm } from 'node:fs/promises';
-import { connect, createServer, type Server } from 'node:net';
-import { homedir, tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import type { JsonObject } from '../being/index.ts';
-import { FolderCustody, FolderMemory } from '../folder/index.ts';
-import type { Defaults, GroundProbe, Harbor, RootRequest } from '../harbor/index.ts';
-import { webServe } from '../http/index.ts';
-import { CryptoEntropy, PointerTerrain, SourceLoader } from '../pointer/index.ts';
-import { NodeSockets } from '../tcp/index.ts';
-
-export const NODE = 'node';
-
-// Where a harbor of this user lives unless named: $NERVUR_DIR, then
-// ~/.nervur.
-export const harborDir = (env: Record<string, string | undefined> = process.env): string => env.NERVUR_DIR ?? join(homedir(), '.nervur');
-
-// A socket path has a hundred bytes or so on every system, so a folder too
-// deep for one puts its socket in this user's temporary folder, under a
-// name drawn from the folder's own path.
-const SOCKET_PATH = 100;
-export const socketOf = (dir: string): string => {
-  const beside = join(resolve(dir), 'root.sock');
-  if (Buffer.byteLength(beside) <= SOCKET_PATH) return beside;
-  return join(tmpdir(), `nervur-${createHash('sha256').update(resolve(dir)).digest('hex').slice(0, 32)}.sock`);
-};
-
-// One root request over a served harbor's socket, or undefined where none
-// is served.
-export const askServed = (dir: string, request: RootRequest): Promise<JsonObject | undefined> =>
-  new Promise((done, fail) => {
-    const socket = connect(socketOf(dir));
-    let text = '';
-    socket.once('connect', () => socket.write(`${JSON.stringify(request)}\n`));
-    socket.on('data', (chunk: Buffer) => {
-      text += chunk.toString('utf8');
-      const end = text.indexOf('\n');
-      if (end < 0) return;
-      socket.end();
-      done(JSON.parse(text.slice(0, end)) as JsonObject);
-    });
-    socket.once('error', (e: NodeJS.ErrnoException) => (e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? done(undefined) : fail(e)));
-  });
-
-export type NodeParts = {
-  readonly dir: string;
-  readonly defaults: Defaults;
-  // Whether its carriers wake, and whether it serves the root line.
-  readonly wakes?: boolean;
-  readonly serves?: boolean;
-};
-
-export class NodeTerrain extends PointerTerrain {
-  readonly dir: string;
-  readonly serves: boolean;
-  #server: Server | undefined;
-
-  constructor(parts: NodeParts) {
-    const entropy = new CryptoEntropy();
-    super({
-      entropy,
-      loader: new SourceLoader(),
-      custody: new FolderCustody(parts.dir, entropy),
-      memory: new FolderMemory(parts.dir),
-      tcp: () => new NodeSockets(),
-      web: webServe,
-      defaults: parts.defaults,
-      wakes: parts.wakes ?? true,
-    });
-    this.dir = parts.dir;
-    this.serves = parts.serves ?? true;
-  }
-
-  override async claim(): Promise<void> {
-    if ((await askServed(this.dir, {})) !== undefined) throw new Error(`a harbor is already served from ${this.dir}`);
-  }
-
-  // The root line on the socket. A socket file nobody answers on is a
-  // stale one, and is replaced.
-  override async stand(harbor: Harbor): Promise<void> {
-    if (!this.serves) return;
-    const root = socketOf(this.dir);
-    await rm(root, { force: true });
-    const server = createServer((socket) => {
-      let text = '';
-      socket.on('data', (chunk: Buffer) => {
-        text += chunk.toString('utf8');
-        for (let end = text.indexOf('\n'); end >= 0; end = text.indexOf('\n')) {
-          const line = text.slice(0, end);
-          text = text.slice(end + 1);
-          let value: unknown;
-          try {
-            value = JSON.parse(line);
-          } catch {
-            value = undefined;
-          }
-          void harbor
-            .ask(value)
-            .catch(() => ({ error: 'the harbor threw' }))
-            .then((answer) => socket.write(`${JSON.stringify(answer)}\n`));
-        }
-      });
-      socket.on('error', () => socket.destroy());
-    });
-    await new Promise<void>((done) => server.listen(root, done));
-    await chmod(root, 0o600);
-    this.#server = server;
-  }
-
-  override async release(): Promise<void> {
-    const server = this.#server;
-    if (!server) return;
-    this.#server = undefined;
-    await new Promise((done) => server.close(done));
-    await rm(socketOf(this.dir), { force: true });
-  }
-}
-
-// Node, and the engines that answer as Node does.
-export const nodeGround: GroundProbe = {
-  name: NODE,
-  fits: () => typeof process !== 'undefined' && typeof process.versions?.node === 'string',
-  terrain: ({ where }, defaults) => new NodeTerrain({ dir: where ?? harborDir(), defaults }),
-};

package/src/core/pointer/bodies.ts

@@ -1,122 +0,0 @@
-// 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, linked, Loader, Memory, moduleOf, type Bundled, type Module } from '../contract/index.ts';
-import { blob, idOf } from '../git/index.ts';
-
-export class CryptoEntropy extends Entropy {
-  draw(length: number): Uint8Array {
-    return globalThis.crypto.getRandomValues(new Uint8Array(length));
-  }
-}
-
-export class SystemClock extends Clock {
-  now(): number {
-    return Date.now();
-  }
-  wait(ms: number): { done: Promise<void>; cancel(): void } {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const done = new Promise<void>((resolve) => (timer = setTimeout(resolve, ms)));
-    return { done, cancel: () => clearTimeout(timer) };
-  }
-}
-
-// The harbor's seed, drawn once and held by this object.
-export class HeldCustody extends Custody {
-  readonly #seed: Uint8Array;
-  constructor(entropy: Entropy) {
-    super();
-    this.#seed = entropy.draw(32);
-  }
-  seed(): Promise<Uint8Array> {
-    return Promise.resolve(this.#seed.slice());
-  }
-}
-
-// How this engine imports a module it is handed as text: from a Blob URL
-// where it imports one, as a browser, Deno and Bun do, and else from a
-// data: URL, as Node does. Bun reads a data: URL as a module that exports
-// nothing, so the Blob URL is tried first, once, with a module of one
-// export.
-type Importer = (text: string) => Promise<unknown>;
-const fromBlob: Importer = async (text) => {
-  const url = URL.createObjectURL(new Blob([text], { type: 'text/javascript' }));
-  try {
-    return await import(url);
-  } finally {
-    URL.revokeObjectURL(url);
-  }
-};
-const fromData: Importer = (text) => import(`data:text/javascript;charset=utf-8,${encodeURIComponent(text)}`);
-let importer: Promise<Importer> | undefined;
-const importerHere = (): Promise<Importer> =>
-  (importer ??= fromBlob('export const probe = 1;').then(
-    (m) => ((m as { probe?: unknown }).probe === 1 ? fromBlob : fromData),
-    () => fromData,
-  ));
-
-// A module's source run by the engine's own `import()`, its `'nervur'`
-// linked to the kit running: Node, Deno, Bun, a browser's page and shared
-// worker, and every engine that imports what it is handed.
-export class SourceLoader extends Loader {
-  async load(source: string): Promise<Module> {
-    const text = linked(source);
-    let exported: unknown;
-    try {
-      exported = await (await importerHere())(text);
-    } catch (e) {
-      throw new Error(`the module did not load: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
-    }
-    return moduleOf(exported);
-  }
-}
-
-// The modules a bundle carries, found by content alone: the git id of a
-// source's blob names the module built from it. An edge evaluates no code
-// it is handed, so a source whose blob the bundle does not carry needs a
-// deploy that carries it.
-export class BundleLoader extends Loader {
-  readonly #bundle: readonly Bundled[];
-  #ids: Promise<Map<string, Module>> | undefined;
-  constructor(bundle: readonly Bundled[] = []) {
-    super();
-    this.#bundle = bundle;
-  }
-  async load(_source: string, id: string): Promise<Module> {
-    this.#ids ??= Promise.all(this.#bundle.map(async (b): Promise<[string, Module]> => [await idOf(blob(b.source)), b.module])).then((ids) => new Map(ids));
-    const found = (await this.#ids).get(id);
-    if (found) return moduleOf(found);
-    const carried = this.#bundle.map((b) => b.module.module);
-    throw new Error(`redeploy needed: blob ${id} is no module this bundle carries${carried.length === 0 ? ', and it carries none' : `: it carries ${carried.join(', ')}`}`);
-  }
-}
-
-// Entries that live as long as this object, copied in and out, which is
-// what a restart in one process finds.
-export class VolatileMemory extends Memory {
-  readonly #places = new Map<string, Map<string, Uint8Array>>();
-  read(place: string): Promise<Map<string, Uint8Array>> {
-    const entries = this.#places.get(place) ?? new Map<string, Uint8Array>();
-    return Promise.resolve(new Map([...entries].map(([name, bytes]) => [name, bytes.slice()])));
-  }
-  // One object holds it, so a keep is whole by the run of one turn.
-  write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void> {
-    let kept = this.#places.get(place);
-    if (!kept) this.#places.set(place, (kept = new Map()));
-    for (const [name, bytes] of entries) {
-      if (bytes === null) kept.delete(name);
-      else kept.set(name, bytes.slice());
-    }
-    if (kept.size === 0) this.#places.delete(place);
-    return Promise.resolve();
-  }
-
-  places(): Promise<string[]> {
-    return Promise.resolve([...this.#places.keys()]);
-  }
-
-  forget(place: string): Promise<void> {
-    this.#places.delete(place);
-    return Promise.resolve();
-  }
-}

package/src/core/pointer/index.ts

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

package/src/core/pointer/world.ts

@@ -1,134 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The pointer world: harbors in one process, an address book from ward pk
-// to harbor that stands in for the internet, and weather between them. A
-// restart drops a harbor and opens a new one on the terrain the world
-// keeps for it, so only what its memory kept comes back.
-import { Carrier, type Clock, type Custody, type Entropy, type Loader, type Memory } from '../contract/index.ts';
-import { Harbor, Terrain, type Defaults, type Sockets, type WebServe } from '../harbor/index.ts';
-import { CryptoEntropy, HeldCustody, SourceLoader, SystemClock, VolatileMemory } from './bodies.ts';
-
-// A carrier that reaches no one: a harbor alone.
-export class NoCarrier extends Carrier {
-  carry(): Promise<Uint8Array | null> {
-    return Promise.resolve(null);
-  }
-}
-
-// Bytes to whichever harbor of a world holds the ward pk.
-export class PointerCarrier extends Carrier {
-  readonly #world: World;
-  constructor(world: World) {
-    super();
-    this.#world = world;
-  }
-  carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    return this.#world.carry(pk, bytes);
-  }
-}
-
-// The bodies a pointer terrain is built of, each the pointer's own where
-// none is handed, save the defaults, which the core never names and an
-// entry always hands.
-export type PointerParts = {
-  entropy?: Entropy;
-  clock?: Clock;
-  custody?: Custody;
-  memory?: Memory;
-  carrier?: Carrier;
-  loader?: Loader;
-  tcp?: () => Sockets;
-  web?: WebServe;
-  defaults: Defaults;
-  wakes?: boolean;
-};
-
-export class PointerTerrain extends Terrain {
-  readonly entropy: Entropy;
-  readonly clock: Clock;
-  readonly custody: Custody;
-  readonly memory: Memory;
-  readonly carrier: Carrier;
-  readonly loader: Loader;
-  readonly defaults: Defaults;
-  override readonly tcp: (() => Sockets) | undefined;
-  override readonly web: WebServe | undefined;
-  override readonly wakes: boolean;
-
-  constructor(parts: PointerParts) {
-    super();
-    this.entropy = parts.entropy ?? new CryptoEntropy();
-    this.clock = parts.clock ?? new SystemClock();
-    this.custody = parts.custody ?? new HeldCustody(this.entropy);
-    this.memory = parts.memory ?? new VolatileMemory();
-    this.carrier = parts.carrier ?? new NoCarrier();
-    this.loader = parts.loader ?? new SourceLoader();
-    this.defaults = parts.defaults;
-    this.tcp = parts.tcp;
-    this.web = parts.web;
-    this.wakes = parts.wakes ?? true;
-  }
-}
-
-type Place = { harbor: Harbor; terrain: Terrain };
-
-// Bodies a harbor of a world is built of beside the world's own.
-export type WorldParts = Partial<Omit<PointerParts, 'carrier'>>;
-
-export class World {
-  readonly #places = new Map<string, Place>();
-  readonly #defaults: Defaults;
-  // Harbors the world reaches no one in, nor anyone out of.
-  readonly cut = new Set<string>();
-
-  // A world whose harbors run the defaults handed, unless one is handed
-  // others.
-  constructor(defaults: Defaults) {
-    this.#defaults = defaults;
-  }
-
-  // A harbor of this world. `parts` replaces the pointer bodies, a folder's
-  // memory and custody among them, and a bundle's loader for an engine
-  // that imports no source. The harbor runs only the modules its catalogue
-  // was told to add. The world holds it as a program does, so once it
-  // opens the world asks its `stand`.
-  async harbor(name: string, parts: WorldParts = {}): Promise<Harbor> {
-    if (this.#places.has(name)) throw new Error(`a harbor named ${name} stands`);
-    const terrain = new PointerTerrain({ defaults: this.#defaults, ...parts, carrier: new PointerCarrier(this) });
-    const harbor = await World.#standing(terrain);
-    this.#places.set(name, { harbor, terrain });
-    return harbor;
-  }
-
-  static async #standing(terrain: Terrain): Promise<Harbor> {
-    const harbor = await Harbor.open(terrain);
-    await harbor.ask({ method: 'stand' });
-    return harbor;
-  }
-
-  get(name: string): Harbor {
-    const place = this.#places.get(name);
-    if (!place) throw new Error(`no harbor named ${name}`);
-    return place.harbor;
-  }
-
-  // The harbor opened again on its own terrain. `parts` replaces bodies of
-  // the terrain, as a new process would build them over the same disk, or
-  // with other code.
-  async restart(name: string, parts?: WorldParts): Promise<Harbor> {
-    const place = this.#places.get(name);
-    if (!place) throw new Error(`no harbor named ${name}`);
-    const t = place.terrain;
-    const kept = { entropy: t.entropy, clock: t.clock, custody: t.custody, memory: t.memory, loader: t.loader, defaults: t.defaults, ...(t.tcp ? { tcp: t.tcp } : {}), ...(t.web ? { web: t.web } : {}) };
-    const terrain = parts ? new PointerTerrain({ ...kept, ...parts, carrier: t.carrier }) : t;
-    const harbor = await World.#standing(terrain);
-    this.#places.set(name, { harbor, terrain });
-    return harbor;
-  }
-
-  carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    for (const [name, { harbor }] of this.#places) {
-      if (harbor.holds(pk)) return this.cut.has(name) ? Promise.resolve(null) : harbor.arrive(pk, bytes);
-    }
-    return Promise.resolve(null);
-  }
-}

package/src/core/proof/contracts.ts

@@ -1,134 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The suites of the bodies, Custody, Memory, Entropy and Loader, as scenes
-// with no platform under them, so Node's runner, every engine and a
-// stranger's own runner hold a body to the same assertions.
-import { Custody, Entropy, Loader, Memory } from '../contract/index.ts';
-import type { Expect } from './expect.ts';
-
-export type Scene = [string, () => Promise<void>];
-
-const bytes = (...values: number[]): Uint8Array => Uint8Array.from(values);
-// A place as plain values, in name order, so two can be compared as JSON.
-const plain = (place: ReadonlyMap<string, Uint8Array>): [string, number[]][] => [...place].map(([n, b]): [string, number[]] => [n, [...b]]).sort(([a], [b]) => (a < b ? -1 : 1));
-
-// `make` gives two bodies over one keeping, as two runs would build them,
-// and a fresh keeping each call.
-export const custodyScenes = (name: string, make: () => [Custody, Custody], expect: Expect): Scene[] => [
-  [
-    `[contract] ${name} fulfils Custody: one seed of thirty-two bytes, the same every time`,
-    async () => {
-      const [custody, again] = make();
-      expect.ok(custody instanceof Custody);
-      const seed = await custody.seed();
-      expect.equal(seed.length, 32);
-      const first = [...seed];
-      seed.fill(0);
-      expect.same([...(await custody.seed())], first, 'a seed handed out is a copy');
-      expect.same([...(await again.seed())], first, 'another body over the keeping holds the same');
-      expect.ok([...(await make()[0].seed())].join() !== first.join(), 'another keeping holds another seed');
-      const [fresh, rival] = make();
-      const [a, b] = await Promise.all([fresh.seed(), rival.seed()]);
-      expect.same([...a], [...b], 'two first asks at once keep one seed');
-    },
-  ],
-];
-
-// `cut` is a body whose next keep stops partway, as a run that dies inside
-// one does, and `fresh` the memory a new run opens on the same keeping. A
-// body no crash can cut short, holding its places in one object, names
-// none.
-export type Cut = { cut: Memory; fresh: Memory };
-
-export const memoryScenes = (name: string, make: () => [Memory, Memory], expect: Expect, half?: () => Cut): Scene[] => [
-  [
-    `[contract] ${name} fulfils Memory: it names its places, and forgets one whole`,
-    async () => {
-      const [memory, again] = make();
-      expect.same(await memory.places(), []);
-      await memory.write('aa', new Map([['01', bytes(1)]]));
-      await memory.write('bb', new Map([['01', bytes(2)], ['02', bytes(3)]]));
-      expect.same([...(await again.places())].sort(), ['aa', 'bb']);
-      await memory.forget('aa');
-      expect.same(await again.places(), ['bb']);
-      expect.same(plain(await again.read('aa')), []);
-      await memory.forget('aa');
-      await memory.write('bb', new Map([['01', null], ['02', null]]));
-      expect.same(await again.places(), [], 'a place holding nothing is no place');
-    },
-  ],
-  ...(half
-    ? [
-        [
-          `[contract] ${name} fulfils Memory: a keep that stops partway is whole or is nothing`,
-          async () => {
-            const { cut, fresh } = half();
-            await cut.write('aa', new Map([['01', bytes(1)], ['02', bytes(2)]])).catch(() => undefined);
-            const before = plain(await fresh.read('aa'));
-            await cut.write('aa', new Map([['01', bytes(9)], ['02', null], ['03', bytes(3)]])).catch(() => undefined);
-            const after = JSON.stringify(plain(await fresh.read('aa')));
-            const whole = JSON.stringify(plain(new Map([['01', bytes(9)], ['03', bytes(3)]])));
-            expect.ok(after === JSON.stringify(before) || after === whole, `a keep cut short left ${after}`);
-          },
-        ] satisfies Scene,
-      ]
-    : []),
-  [
-    `[contract] ${name} fulfils Memory: a place read again holds what was kept, and nothing else`,
-    async () => {
-      const [memory, again] = make();
-      expect.ok(memory instanceof Memory);
-      expect.same(plain(await memory.read('aa')), []);
-      const written = bytes(1, 2, 3);
-      await memory.write('aa', new Map([['01', written], ['02', bytes(4)]]));
-      written[0] = 9;
-      await memory.write('bb', new Map([['01', bytes(5)]]));
-      await memory.write('aa', new Map([['02', null], ['03', bytes()], ['04', null]]));
-      const read = await again.read('aa');
-      expect.same(plain(read), [['01', [1, 2, 3]], ['03', []]]);
-      expect.ok(read.get('01') instanceof Uint8Array, 'an entry is bytes');
-      read.get('01')![0] = 7;
-      expect.same([...(await memory.read('aa')).get('01')!], [1, 2, 3], 'an entry handed out is a copy');
-      expect.same(plain(await again.read('bb')), [['01', [5]]]);
-      expect.same(plain(await again.read('cc')), []);
-    },
-  ],
-];
-
-export const entropyScenes = (name: string, make: () => Entropy, expect: Expect): Scene[] => [
-  [
-    `[contract] ${name} fulfils Entropy: bytes of the length asked, never the same twice`,
-    () => {
-      const entropy = make();
-      expect.ok(entropy instanceof Entropy);
-      expect.equal(entropy.draw(0).length, 0);
-      expect.equal(entropy.drawer(33).length, 33);
-      expect.ok([...entropy.draw(32)].join() !== [...entropy.draw(32)].join(), 'two draws differ');
-      return Promise.resolve();
-    },
-  ],
-];
-
-// A module's source as bytes and its blob's git id, the two things a
-// loader is handed.
-export type Source = { source: string; id: string };
-
-// `make` gives a loader, a module's source it runs, and a source it
-// refuses: one that does not load, or, for a bundle, one it does not carry.
-export const loaderScenes = (name: string, make: () => { loader: Loader; found: Source; refused: Source }, expect: Expect): Scene[] => [
-  [
-    `[contract] ${name} fulfils Loader: a module's source becomes that module, the same again, and a source it cannot run throws`,
-    async () => {
-      const { loader, found, refused } = make();
-      expect.ok(loader instanceof Loader);
-      const loaded = await loader.load(found.source, found.id);
-      expect.equal(typeof loaded.module, 'string');
-      expect.equal(typeof loaded.version, 'string');
-      expect.ok(Array.isArray(loaded.classes) && loaded.classes.length > 0 && loaded.classes.every((C) => typeof C === 'function'), 'the classes are classes');
-      const again = await loader.load(found.source, found.id);
-      expect.same({ module: again.module, version: again.version }, { module: loaded.module, version: loaded.version });
-      let said = '';
-      await loader.load(refused.source, refused.id).catch((e: Error) => (said = e.message));
-      expect.ok(said !== '', 'a source it cannot run throws, saying why');
-    },
-  ],
-];

package/src/core/proof/expect.ts

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The few assertions a scene needs, with no platform under them, so the
-// same scene runs in Node's runner and inside any other engine.
-export type Expect = {
-  equal(actual: unknown, expected: unknown, message?: string): void;
-  same(actual: unknown, expected: unknown, message?: string): void;
-  ok(value: unknown, message?: string): void;
-};
-
-const fail = (message: string | undefined, detail: string): never => {
-  throw new Error(`${message ? `${message}: ` : ''}${detail}`);
-};
-
-export const expect: Expect = {
-  equal: (actual, expected, message) => {
-    if (!Object.is(actual, expected)) fail(message, `${String(actual)} is not ${String(expected)}`);
-  },
-  same: (actual, expected, message) => {
-    const [a, b] = [JSON.stringify(actual), JSON.stringify(expected)];
-    if (a !== b) fail(message, `${a} is not ${b}`);
-  },
-  ok: (value, message) => {
-    if (!value) fail(message, 'not true');
-  },
-};