nervur 0.22.0 → 0.22.2-3

package/src/core/cli/edge.ts

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur edge dev`: an edge harbor on this machine, as it will stand on
-// Cloudflare. The harbor of a folder is packed under its name into the
-// pack the worker imports, beside the harbors the pack holds already, and
-// the worker's own `wrangler dev` runs them all, in the folder the command
-// runs from, with the secret handed as `NERVUR_SECRET` through the
-// environment so no listing of processes shows it. The secret is the one
-// the command's environment names, or one drawn once and kept under
-// `.nervur-edge`, beside the objects' storage, so a harbor landed once
-// stands again across restarts, as it does on Cloudflare.
-//
-// wrangler is the worker's tool and never the kit's: the one who deploys
-// an edge has it already, and `edge dev` finds it where npm put it.
-import { spawn, type ChildProcess } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { hex } from '../crypto/index.ts';
-import { CryptoEntropy } from '../pointer/index.ts';
-import { pack } from './harbor.ts';
-
-export const EDGE_STATE = '.nervur-edge';
-// A refused fetch costs next to nothing, so wrangler is asked often and is
-// found the moment it answers, within the same minute as ever.
-const READY_TRIES = 2400;
-const READY_EVERY = 25;
-
-export type EdgeDev = { readonly at: string; readonly places: number; close(): Promise<void> };
-
-const answers = (url: string): Promise<boolean> =>
-  fetch(url).then(
-    () => true,
-    () => false,
-  );
-
-// Resolved once wrangler answers at `url`, rejected once it exits or never
-// answers.
-const ready = async (child: ChildProcess, url: string, said: () => string): Promise<void> => {
-  let gone = false;
-  child.once('exit', () => (gone = true));
-  for (let i = 0; i < READY_TRIES; i += 1) {
-    if (gone) throw new Error(`wrangler dev exited: ${said()}`);
-    if (await answers(url)) return;
-    await new Promise((r) => setTimeout(r, READY_EVERY));
-  }
-  throw new Error(`wrangler dev never answered at ${url}: ${said()}`);
-};
-
-// The secret `edge dev` runs under: the one named, or the one kept here.
-const devSecret = async (state: string, named: string | undefined): Promise<string> => {
-  if (named) return named;
-  const file = join(state, 'secret');
-  if (!existsSync(file)) {
-    await mkdir(state, { recursive: true, mode: 0o700 });
-    await writeFile(file, `${hex(new CryptoEntropy().draw(32))}\n`, { mode: 0o600, flag: 'wx' });
-  }
-  return (await readFile(file, 'utf8')).trim();
-};
-
-export const edgeDev = async (dir: string, file: string, name: string, cwd: string, port: number, named?: string): Promise<EdgeDev> => {
-  const state = join(cwd, EDGE_STATE);
-  const secret = await devSecret(state, named);
-  const { places } = (await pack(dir, file, name, secret)) as { places: number };
-  const child = spawn('npx', ['--no-install', 'wrangler', 'dev', '--ip', '127.0.0.1', '--port', String(port), '--persist-to', state, '--log-level', 'warn'], {
-    cwd,
-    env: { ...process.env, NERVUR_SECRET: secret, CLOUDFLARE_INCLUDE_PROCESS_ENV: 'true' },
-    stdio: ['ignore', 'ignore', 'pipe'],
-    detached: true,
-  });
-  let err = '';
-  child.stderr!.on('data', (chunk: Buffer) => (err = `${err}${chunk.toString('utf8')}`.slice(-4000)));
-  const at = `http://127.0.0.1:${String(port)}/${name}/quo`;
-  const close = (): Promise<void> =>
-    new Promise((done) => {
-      if (child.exitCode !== null) return done();
-      child.once('exit', () => done());
-      process.kill(-child.pid!, 'SIGTERM');
-    });
-  try {
-    await ready(child, at, () => err);
-  } catch (e) {
-    await close();
-    throw e;
-  }
-  return { at, places, close };
-};

package/src/core/cli/harbor.ts

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A harbor on this machine, as the `nervur` command stands it: a harbor of
-// the Node ground in a folder, served while `serve` runs, and asked over
-// its root line's socket.
-//
-// A root request goes to a served harbor over its socket. With none served,
-// the command unpacks the harbor from its folder, asks, and closes it, so
-// one process at a time writes the folder.
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { JsonObject } from '../being/index.ts';
-import { hex, unhex } from '../crypto/index.ts';
-import { isHarborName, readPack, sealSeed, type Pack } from '../edge/index.ts';
-import { FolderCustody, FolderMemory } from '../folder/index.ts';
-import { carrierIn, carryPlaces, Harbor, landPlaces, readCarried, type Carried, type Defaults, type RootRequest } from '../harbor/index.ts';
-import { askServed, NodeTerrain, socketOf } from '../node/index.ts';
-import { CryptoEntropy } from '../pointer/index.ts';
-import { tcpAddress } from '../quo/index.ts';
-
-// A harbor of a folder, opened for one ask: it listens nowhere and serves
-// nothing.
-// Every harbor the command opens runs the defaults its entry hands it, and
-// the command holds it, so it asks its `stand` once it opens.
-const standing = async (terrain: NodeTerrain): Promise<Harbor> => {
-  const harbor = await Harbor.open(terrain);
-  await harbor.ask({ method: 'stand' });
-  return harbor;
-};
-
-// The box ward's census, as the root reads it.
-export type Census = { pk: string; beings: Record<string, { class: string; absent: boolean }>; listening: string[] };
-export const census = async (harbor: Harbor): Promise<Census> => ((await harbor.ask({})).answer as { notes: Census }).notes;
-
-export const open = (dir: string, defaults: Defaults): Promise<Harbor> => standing(new NodeTerrain({ dir, defaults, wakes: false, serves: false }));
-
-// Whether a harbor of this folder is served now.
-export const isServed = async (dir: string): Promise<boolean> => (await askServed(dir, {})) !== undefined;
-
-export const request = async (dir: string, defaults: Defaults, req: RootRequest): Promise<JsonObject> => {
-  const served = await askServed(dir, req);
-  if (served !== undefined) return served;
-  const harbor = await open(dir, defaults);
-  try {
-    return await harbor.ask(req);
-  } finally {
-    await harbor.close();
-  }
-};
-
-// The harbor of a folder, read as bytes alone, its seed only where the
-// one who asks says so, since custody holds it and a package without it
-// opens nowhere. No harbor opens, so nothing is asked and nothing is
-// written.
-export const carry = async (dir: string, seed: boolean): Promise<Carried> => ({
-  ...(seed ? { seed: hex(await new FolderCustody(dir, new CryptoEntropy()).seed()) } : {}),
-  places: await carryPlaces(new FolderMemory(dir)),
-});
-
-// What `nervur edge pack` hands a deploy: the harbor of a folder, under
-// its name, in the pack the worker bundles, its seed sealed under the
-// worker's `NERVUR_SECRET` beside its sealed places. Its code travels in
-// its places, as its DNA, so the edge loads what `live` names from there.
-// Every other harbor the pack holds stays, so one worker carries them all,
-// and nothing in the pack opens without the secret.
-export const pack = async (dir: string, file: string, name: string, secret: string | undefined): Promise<JsonObject> => {
-  if (!isHarborName(name)) throw new Error(`${name} is no harbor name: lowercase letters, digits and -`);
-  if (!secret) throw new Error('edge pack seals the seed under NERVUR_SECRET, and none is set');
-  if (!existsSync(join(dir, 'seed'))) throw new Error(`no harbor stands at ${dir}`);
-  const { seed, places } = await carry(dir, true);
-  const held = existsSync(file) ? readPack(JSON.parse(await readFile(file, 'utf8'))) : {};
-  if (held === null) throw new Error(`${file} is no pack`);
-  const packed: Pack = { ...held, [name]: { sealed: await sealSeed(secret, unhex(seed!)), places } };
-  await writeFile(file, `${JSON.stringify(packed)}\n`, { mode: 0o600 });
-  return { packed: name, package: file, harbors: Object.keys(packed).sort(), places: Object.keys(places).length };
-};
-
-// A carried harbor into an empty folder. A folder holding a seed or a
-// place is left as it stands, and a package with no seed needs one there
-// already, which a terrain that seals its custody writes its own way.
-export const land = async (dir: string, value: unknown): Promise<string[]> => {
-  const held = readCarried(value);
-  if (held === null) throw new Error('that is no carried harbor');
-  const memory = new FolderMemory(dir);
-  if ((await memory.places()).length > 0 || (held.seed !== undefined && existsSync(join(dir, 'seed')))) throw new Error(`a harbor stands at ${dir}`);
-  await mkdir(dir, { recursive: true, mode: 0o700 });
-  if (held.seed !== undefined) await writeFile(join(dir, 'seed'), `${held.seed}\n`, { mode: 0o600, flag: 'wx' });
-  else if (!existsSync(join(dir, 'seed'))) throw new Error('the package carries no seed, and none is held here');
-  return landPlaces(memory, held);
-};
-
-// A served harbor: its pk, its tcp address, every address its carriers
-// listen at, and its root line's socket.
-export type Served = { pk: string; at: string; listening: string[]; root: string; close(): Promise<void> };
-
-// The harbor served: a harbor of the Node ground, with Quo over the TCP
-// carrier its root opened, on host and port. Serving adds nothing to the
-// harbor, so one with no TCP carrier is not served.
-export const serve = async (dir: string, defaults: Defaults, host?: string, port?: number): Promise<Served> => {
-  if (!existsSync(join(dir, 'seed'))) throw new Error(`no harbor stands at ${dir}: init one first`);
-  const harbor = await standing(new NodeTerrain({ dir, defaults }));
-  const tcpOf = (listening: string[]): string | undefined => listening.find((address) => tcpAddress(address) !== null);
-  const before = await census(harbor);
-  const present = Object.fromEntries(Object.entries(before.beings).filter(([, being]) => !being.absent));
-  const tcp = carrierIn(present, defaults.classes, 'tcp');
-  if (tcp?.open !== undefined || tcp === null) {
-    await harbor.close();
-    const kind = tcp?.open?.args?.class;
-    throw new Error(`the harbor at ${dir} has no tcp carrier${typeof kind === 'string' ? `: open one with \`nervur open tcp ${kind}\`` : ''}`);
-  }
-  if (host !== undefined || port !== undefined || tcpOf(before.listening) === undefined) {
-    const heard = await harbor.ask({ method: 'ask', args: { being: tcp.key, method: 'listen', args: { ...(host === undefined ? {} : { host }), ...(port === undefined ? {} : { port }) } } });
-    if (typeof ((heard.answer as JsonObject | undefined)?.answer as JsonObject | undefined)?.at !== 'string') {
-      await harbor.close();
-      throw new Error(`the harbor does not listen: ${JSON.stringify(heard.answer ?? heard)}`);
-    }
-  }
-  const { pk, listening } = await census(harbor);
-  return { pk, at: tcpOf(listening)!, listening, root: socketOf(dir), close: () => harbor.close() };
-};

package/src/core/contract/index.ts

@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The contracts: what the onion cannot unpack from cells, a module's code
-// among them, each an abstract class, so a registry can tell at run time
-// which class fulfils which. The class differs by terrain, and the
-// contract does not.
-import type { Draw } from '../quo/index.ts';
-
-// Drawn bytes.
-export abstract class Entropy {
-  abstract draw(length: number): Uint8Array;
-  // The same source, as the function `quo/` takes.
-  get drawer(): Draw {
-    return (length) => this.draw(length);
-  }
-}
-
-// The moment, and a wait that ends.
-export abstract class Clock {
-  abstract now(): number;
-  // Resolves after `ms`, unless cancelled first.
-  abstract wait(ms: number): { done: Promise<void>; cancel(): void };
-}
-
-// One ward's partition, as the harbor's package opens it: the rows the
-// ward writes into directly, told after every write, and kept once at the
-// end of an arrival.
-export interface Rows {
-  readonly rows: Record<string, unknown>;
-  told(row: string): void;
-  kept(): Promise<boolean>;
-}
-
-// A harbor's memory as a terrain keeps it: sealed entries it cannot read,
-// in places, each entry by name. Every name is lowercase hex the kit
-// chose, so a body may use it as a file name as it stands.
-export abstract class Memory {
-  // Every entry kept in a place; a place nothing was kept in is empty.
-  abstract read(place: string): Promise<Map<string, Uint8Array>>;
-  // One keep, whole: every entry written and every null removed together,
-  // or none of them. A read after a keep that did not finish, in this run
-  // or in the run before it, holds the place as it was or as the keep
-  // leaves it, and never half of each.
-  abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
-  // Every place this memory holds something in, in any order.
-  abstract places(): Promise<string[]>;
-  // A place and everything in it, gone.
-  abstract forget(place: string): Promise<void>;
-}
-
-// The harbor's seed: thirty-two bytes, the same every time. It is the one
-// secret a terrain holds.
-export abstract class Custody {
-  abstract seed(): Promise<Uint8Array>;
-}
-
-// A module: the code a harbor's classes come from. It declares its own
-// name, a reversed domain as a kind is, and its version.
-export type Module = { readonly module: string; readonly version: string; readonly classes: readonly unknown[] };
-
-// Bytes become a module. A module's source is one self-contained ES
-// module that imports nothing but `'nervur'`, and `id` is the git id of
-// its blob, the one name a bundle finds it by. What does not load throws,
-// saying why. How code runs differs by ground, an import of a data: URL,
-// of a Blob URL, or a lookup in the bundle an edge was deployed with, so
-// the loader is the one body beside the seed a terrain hands in that code
-// passes through.
-export abstract class Loader {
-  abstract load(source: string, id: string): Promise<Module>;
-}
-
-// A module a bundle carries: its source, whose blob's id names it, and the
-// module the bundler built from that source.
-export type Bundled = { readonly source: string; readonly module: Module };
-
-export { bindKit, linked, moduleOf } from './link.ts';
-
-// Bytes to a ward pk in; bytes, or null for nothing, out. A harbor hands a
-// terrain's carrier what it holds no route for; what it routes goes to its
-// carrier faculties.
-export abstract class Carrier {
-  abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-}

package/src/core/contract/link.ts

@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A module's `'nervur'` is the kit already running. An author writes
-// `import { Being } from 'nervur'`, and a loader rewrites each such import
-// into a read of this copy's exports before it runs the source, so a
-// class the module declares extends the very `Being` the harbor checks it
-// against. Each copy of the kit a process holds keeps its exports under
-// its own token in one registered map, since two copies in one process are
-// two sets of classes. The entry binds them once it has evaluated.
-import type { Module } from './index.ts';
-
-const KITS = 'org.nervur.kits';
-
-type Kits = Map<string, object>;
-const kits = (): Kits => {
-  const holder = globalThis as unknown as Record<symbol, Kits | undefined>;
-  return (holder[Symbol.for(KITS)] ??= new Map());
-};
-
-// This copy's token, the count of copies bound before it, since an edge
-// draws no random bytes while its script loads.
-let token: string | undefined;
-
-// This copy's exports, as a module's `'nervur'` reads them.
-export const bindKit = (kit: object): void => {
-  const all = kits();
-  token ??= `kit${String(all.size)}`;
-  all.set(token, kit);
-};
-
-const IMPORT = /\bimport\s*(\{[^}]*\}|\*\s*as\s+[A-Za-z_$][\w$]*)\s*from\s*(['"])nervur\2\s*;?/g;
-const OTHER = /(^|[\n;{}])\s*(import\s*[\w{*'"]|export\s*(\*|\{[^}]*\})\s*from\b)/;
-
-// A module's source with its `'nervur'` imports read from this copy, or a
-// throw where it imports anything else.
-export const linked = (source: string): string => {
-  if (token === undefined) throw new Error('no kit is bound to link a module against');
-  const kit = `globalThis[Symbol.for(${JSON.stringify(KITS)})].get(${JSON.stringify(token)})`;
-  const out = source.replace(IMPORT, (_all, names: string) => {
-    if (names.startsWith('*')) return `const ${names.replace(/^\*\s*as\s+/, '')} = ${kit};`;
-    const fields = names
-      .slice(1, -1)
-      .split(',')
-      .map((n) => n.trim())
-      .filter((n) => n !== '')
-      .map((n) => n.replace(/\s+as\s+/, ': '));
-    return `const { ${fields.join(', ')} } = ${kit};`;
-  });
-  if (OTHER.test(out)) throw new Error("a module imports nothing but 'nervur'");
-  return out;
-};
-
-// What a module's code exported, read as a module, or a throw saying what
-// it lacks.
-export const moduleOf = (exported: unknown): Module => {
-  const { module, version, classes } = (exported ?? {}) as { module?: unknown; version?: unknown; classes?: unknown };
-  if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes)) throw new Error('the code exports no module: module, version and classes');
-  return { module, version, classes };
-};

package/src/core/crypto/aes.ts

@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// AES-256-GCM with a sixteen-byte tag at the end of the ciphertext.
-import { own, subtle } from './subtle.ts';
-
-export const TAG = 16;
-
-const cipher = (key: Uint8Array, nonce: Uint8Array, additional: Uint8Array) => ({
-  params: { name: 'AES-GCM', iv: own(nonce), additionalData: own(additional), tagLength: TAG * 8 },
-  key: subtle().importKey('raw', own(key), 'AES-GCM', false, ['encrypt', 'decrypt']),
-});
-
-export const encrypt = async (key: Uint8Array, nonce: Uint8Array, additional: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array> => {
-  const c = cipher(key, nonce, additional);
-  return new Uint8Array(await subtle().encrypt(c.params, await c.key, own(plaintext)));
-};
-
-// The plaintext, or null when the ciphertext does not open.
-export const decrypt = async (key: Uint8Array, nonce: Uint8Array, additional: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array | null> => {
-  if (ciphertext.length < TAG) return null;
-  const c = cipher(key, nonce, additional);
-  try {
-    return new Uint8Array(await subtle().decrypt(c.params, await c.key, own(ciphertext)));
-  } catch {
-    return null;
-  }
-};

package/src/core/crypto/bytes.ts

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Bytes and the one text spelling Quo gives them: hex, two lowercase digits
-// a byte.
-const DIGITS = Array.from({ length: 256 }, (_, at) => at.toString(16).padStart(2, '0'));
-const HEX = /^(?:[0-9a-f]{2})*$/;
-
-export const hex = (bytes: Uint8Array): string => {
-  let out = '';
-  for (const byte of bytes) out += DIGITS[byte];
-  return out;
-};
-
-// Hex of `length` bytes, or any length when none is named.
-export const isHex = (text: unknown, length?: number): text is string =>
-  typeof text === 'string' && HEX.test(text) && (length === undefined || text.length === length * 2);
-
-export const unhex = (text: string): Uint8Array => {
-  if (!isHex(text)) throw new TypeError('not hex');
-  const out = new Uint8Array(text.length / 2);
-  for (let at = 0; at < out.length; at += 1) out[at] = parseInt(text.slice(at * 2, at * 2 + 2), 16);
-  return out;
-};
-
-export const concat = (...parts: Uint8Array[]): Uint8Array => {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let at = 0;
-  for (const part of parts) {
-    out.set(part, at);
-    at += part.length;
-  }
-  return out;
-};
-
-export const zero = (bytes: Uint8Array): boolean => bytes.every((b) => b === 0);
-
-const encoder = new TextEncoder();
-export const utf8 = (text: string): Uint8Array => encoder.encode(text);

package/src/core/crypto/ed25519.ts

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Ed25519 signs, as RFC 8032 defines it, by `@noble/curves` in every
-// engine, since an engine's Web Crypto may refuse a secret the curve takes,
-// and verifies with the cofactorless check the spec names, which the
-// library's own verify does not make. The decoding rules are held here:
-//
-//   a signature of any length but sixty-four
-//   an `s` at or above the group order
-//   an `R` that does not decode, or whose bytes are not its point's encoding
-//   a public key that does not decode, or whose y is at or above the prime
-//   a public key of small order, in any spelling
-import { ed25519 } from '@noble/curves/ed25519.js';
-import { concat } from './bytes.ts';
-import { own, subtle } from './subtle.ts';
-
-const P = 2n ** 255n - 19n;
-const L = 2n ** 252n + 27742317777372353535851937790883648493n;
-
-const mod = (a: bigint): bigint => ((a % P) + P) % P;
-const power = (base: bigint, exponent: bigint): bigint => {
-  let out = 1n;
-  let b = mod(base);
-  for (let e = exponent; e > 0n; e >>= 1n) {
-    if (e & 1n) out = (out * b) % P;
-    b = (b * b) % P;
-  }
-  return out;
-};
-const D = mod(-121665n * power(121666n, P - 2n));
-const ROOT_MINUS_ONE = power(2n, (P - 1n) / 4n);
-
-const little = (bytes: Uint8Array): bigint => bytes.reduceRight((n, b) => (n << 8n) | BigInt(b), 0n);
-
-type Point = { x: bigint; y: bigint; z: bigint; t: bigint };
-
-// A point from its thirty-two bytes, or null where RFC 8032 section 5.1.3
-// refuses it, the sign bit set on x = 0 included.
-const decode = (bytes: Uint8Array): Point | null => {
-  if (bytes.length !== 32) return null;
-  const sign = (bytes[31]! & 0x80) !== 0;
-  const y = little(bytes) & ((1n << 255n) - 1n);
-  if (y >= P) return null;
-  const u = mod(y * y - 1n);
-  const v = mod(D * y * y + 1n);
-  let x = mod(u * power(v, 3n) * power(u * power(v, 7n), (P - 5n) / 8n));
-  const check = mod(v * x * x);
-  if (check === mod(-u)) x = mod(x * ROOT_MINUS_ONE);
-  else if (check !== u) return null;
-  if (x === 0n && sign) return null;
-  if ((x & 1n) !== (sign ? 1n : 0n)) x = mod(-x);
-  return { x, y, z: 1n, t: mod(x * y) };
-};
-
-const add = (a: Point, b: Point): Point => {
-  const A = mod((a.y - a.x) * (b.y - b.x));
-  const B = mod((a.y + a.x) * (b.y + b.x));
-  const C = mod(2n * D * a.t * b.t);
-  const E = mod(2n * a.z * b.z);
-  const [e, f, g, h] = [B - A, E - C, E + C, B + A];
-  return { x: mod(e * f), y: mod(g * h), z: mod(f * g), t: mod(e * h) };
-};
-
-// Small order: eight times the point is the identity.
-const smallOrder = (p: Point): boolean => {
-  let q = p;
-  for (let i = 0; i < 3; i += 1) q = add(q, q);
-  return q.x === 0n && q.y === q.z;
-};
-
-const secretOf = (secret: Uint8Array): Uint8Array => {
-  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
-  return secret;
-};
-
-export const ed25519Public = async (secret: Uint8Array): Promise<Uint8Array> => ed25519.getPublicKey(secretOf(secret));
-
-export const sign = async (secret: Uint8Array, message: Uint8Array): Promise<Uint8Array> => ed25519.sign(message, secretOf(secret));
-
-// The cofactorless check, `[s]B = R + [k]A`, on points decoded as above.
-export const verify = async (pk: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean> => {
-  if (signature.length !== 64) return false;
-  const key = decode(pk);
-  if (key === null || smallOrder(key)) return false;
-  if (decode(signature.subarray(0, 32)) === null) return false;
-  const s = little(signature.subarray(32));
-  if (s >= L) return false;
-  const R = ed25519.Point.fromBytes(signature.subarray(0, 32));
-  const A = ed25519.Point.fromBytes(pk);
-  const hashed = new Uint8Array(await subtle().digest('SHA-512', own(concat(signature.subarray(0, 32), pk, message))));
-  const k = little(hashed) % L;
-  return ed25519.Point.BASE.multiplyUnsafe(s).equals(R.add(A.multiplyUnsafe(k)));
-};

package/src/core/crypto/hash.ts

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SHA-256 hashes, and HKDF-SHA-256 derives under the zero-length salt, with
-// the label's ASCII bytes as `info`.
-import { own, subtle } from './subtle.ts';
-
-const SALT = new Uint8Array(0);
-
-export const sha256 = async (bytes: Uint8Array): Promise<Uint8Array> => new Uint8Array(await subtle().digest('SHA-256', own(bytes)));
-
-export const hkdf = async (ikm: Uint8Array, info: Uint8Array, length: number): Promise<Uint8Array> => {
-  const material = await subtle().importKey('raw', own(ikm), 'HKDF', false, ['deriveBits']);
-  const bits = await subtle().deriveBits({ name: 'HKDF', hash: 'SHA-256', salt: SALT, info: own(info) }, material, length * 8);
-  return new Uint8Array(bits);
-};

package/src/core/crypto/index.ts

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The six algorithms Quo names, and bytes. Arithmetic only: no label, no
-// key of Quo's, no decision.
-export { concat, hex, isHex, unhex, utf8, zero } from './bytes.ts';
-export { hkdf, sha256 } from './hash.ts';
-export { isCount, readObject, readValue, writeValue, type Fields, type Json } from './json.ts';
-export { decrypt, encrypt, TAG } from './aes.ts';
-export { agree, x25519Public } from './x25519.ts';
-export { ed25519Public, sign, verify } from './ed25519.ts';
-export { CIPHERTEXT, decapsulate, EK, encapsulate, lockFrom, type Lock } from './mlkem.ts';