nervur 0.14.0 → 0.16.0

package/being.mjs

@@ -1,639 +0,0 @@
-import { ADMIN } from './admin.mjs';
-import { OPEN, STRUCTURAL, composed, coreClass } from './blueprint.mjs';
-import { Program } from './program.mjs';
-import { Bytes, MEASURE, SPAN, Stamp, Tools } from './tools.mjs';
-import { Voice } from './voice.mjs';
-
-const Compartment = ({ memory, voice, address, root, classOf, cipher }) => {
-  const held = (key) => memory.read(address, key);
-  const sealed = (key) => {
-    const kind = classOf(key);
-    return kind === undefined || OPEN.includes(kind) ? undefined : Tools.derive(root, kind);
-  };
-  const put = (key, value) => {
-    const claim = { address, key, value, version: (held(key)?.version ?? 0) + 1 };
-    return memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) });
-  };
-
-  return Object.freeze({
-    classOf,
-    list: (prefix) =>
-      memory.list(address, prefix).filter((key) => memory.read(address, key)?.value !== null),
-    read: (key) => {
-      const cell = held(key);
-      if (cell === undefined || cell.value === null || classOf(key) === undefined) {
-        return undefined;
-      }
-      const secret = sealed(key);
-      if (secret === undefined) {
-        return cell.value;
-      }
-      return cipher === undefined ? undefined : cipher.unseal(secret, cell.value);
-    },
-    write: (key, plain) => {
-      if (classOf(key) === undefined) {
-        return undefined;
-      }
-      if (plain === undefined) {
-        return put(key, null);
-      }
-      const secret = sealed(key);
-      if (secret === undefined) {
-        return put(key, plain);
-      }
-      if (cipher === undefined) {
-        return undefined;
-      }
-      const shut = cipher.seal(secret, plain);
-      return shut === undefined ? undefined : put(key, shut);
-    },
-  });
-};
-
-const spanOf = (given) =>
-  typeof given === 'number' && Number.isFinite(given) && given > 0 && given < SPAN ? given : SPAN;
-
-const within = (span, work) => {
-  let timer;
-  const lapsed = new Promise((settle) => {
-    timer = setTimeout(() => settle(undefined), span);
-    timer.unref?.();
-  });
-  return Promise.race([work, lapsed]).finally(() => clearTimeout(timer));
-};
-
-const Fence = () => {
-  let standing = true;
-  return Object.freeze({
-    close: () => {
-      standing = false;
-      return undefined;
-    },
-    open: () => standing,
-  });
-};
-
-const fenced = (mine, fence) =>
-  Object.freeze({
-    classOf: mine.classOf,
-    list: mine.list,
-    read: mine.read,
-    write: (key, plain) => (fence.open() ? mine.write(key, plain) : undefined),
-  });
-
-const custodial = (registry, fence) =>
-  registry === undefined
-    ? undefined
-    : Object.freeze({
-        ...registry,
-        create: (one) => (fence.open() ? registry.create(one) : undefined),
-        destroy: (at) => (fence.open() ? registry.destroy(at) : undefined),
-        extend: (source) => (fence.open() ? registry.extend(source) : undefined),
-        upgrade: (one) => (fence.open() ? registry.upgrade(one) : undefined),
-      });
-
-const offered = (modules, program, mine, seat) =>
-  Object.freeze({
-    ...Object.fromEntries(
-      (program?.modules ?? [])
-        .map((one) => one.module)
-        .filter((name) => name !== 'memory' && modules[name] !== undefined)
-        .map((name) => [name, modules[name]]),
-    ),
-    memory: scoped(mine, program, seat),
-  });
-
-const grantable = (program) =>
-  (program?.rights ?? [...STRUCTURAL, 'MEMBER']).filter((one) => !STRUCTURAL.includes(one));
-
-const HORIZON = 7_776_000_000;
-
-const whole = (one) => Number.isSafeInteger(one) && one >= 0;
-
-const invitation = (plain, rights, program, seat) => {
-  const count = plain.count ?? 1;
-  const expiresAt = plain.expiresAt ?? 0;
-  if (!whole(count) || count < 1 || !whole(expiresAt)) {
-    return undefined;
-  }
-  const now = seat.now();
-  if (seat.administration) {
-    return count === 1 && expiresAt > 0 && expiresAt < now + HORIZON
-      ? { ...plain, count, expiresAt, rights }
-      : undefined;
-  }
-  const ceiling = program?.invites?.(rights);
-  if (ceiling !== undefined) {
-    if (ceiling.count > 0 && count > ceiling.count) {
-      return undefined;
-    }
-    if (ceiling.within > 0 && (expiresAt === 0 || expiresAt > now + ceiling.within)) {
-      return undefined;
-    }
-  }
-  return { ...plain, count, expiresAt, rights };
-};
-
-const referable = (mine, key, plain, program, seat) => {
-  const rights = plain.rights ?? 'MEMBER';
-  if (!grantable(program).includes(rights)) {
-    return undefined;
-  }
-  if (key.startsWith('refs/pending/')) {
-    return invitation(plain, rights, program, seat);
-  }
-  const held = mine.read(key);
-  if (
-    held?.nextPkHash != null &&
-    plain.nextPkHash !== undefined &&
-    plain.nextPkHash !== null &&
-    plain.nextPkHash !== held.nextPkHash
-  ) {
-    return undefined;
-  }
-  return {
-    ...plain,
-    nextPkHash: plain.nextPkHash ?? held?.nextPkHash ?? null,
-    rights,
-    seen: Math.max(plain.seen ?? 0, held?.seen ?? 0),
-  };
-};
-
-const scoped = (mine, program, seat) =>
-  Object.freeze({
-    classOf: mine.classOf,
-    list: mine.list,
-    read: mine.read,
-    write: (key, plain) => {
-      if (key.startsWith('refs/') && plain !== undefined) {
-        const guarded = referable(mine, key, plain, program, seat);
-        return guarded === undefined ? undefined : mine.write(key, guarded);
-      }
-      return key.startsWith('refs/') ||
-        key.startsWith('handles/') ||
-        program?.declares(key) !== undefined
-        ? mine.write(key, plain)
-        : undefined;
-    },
-  });
-
-const rootFor = ({ memory, voice, address, cipher }) => {
-  const cell = memory.read(address, `keyring/${Tools.address(voice.pk)}`);
-  const opened = cell === undefined ? undefined : voice.open(cell.value.wrapped, cipher);
-  return opened === undefined ? undefined : Bytes.unbase64(opened);
-};
-
-const Port = ({ voice, mine, deliver, rights, stamp, lanes, fence }) => {
-  const send = async (to, op) => {
-    if (fence !== undefined && !fence.open()) {
-      return undefined;
-    }
-    const turn = (lanes.get(to) ?? Promise.resolve()).then(async () => {
-      const handle = mine.read(`handles/${to}`);
-      const envelope = await Tools.envelope(
-        handle === undefined ? voice : Voice.revive(handle.face),
-        to,
-        op,
-        stamp(),
-      );
-      const claim = Tools.digest(
-        Tools.canon({ from: envelope.from, op: envelope.op, seq: envelope.seq, to: envelope.to }),
-      );
-      const reply = await deliver(envelope);
-      return reply === undefined ? undefined : { ...reply, claim };
-    });
-    const settled = turn.then(
-      () => undefined,
-      () => undefined,
-    );
-    lanes.set(to, settled);
-    settled.then(() => {
-      if (lanes.get(to) === settled) {
-        lanes.delete(to);
-      }
-    });
-    return turn;
-  };
-  return Object.freeze({
-    face: (to) => {
-      const handle = mine.read(`handles/${to}`);
-      return Tools.address(handle === undefined ? voice.pk : Voice.revive(handle.face).pk);
-    },
-    mint: (to) => {
-      const minted = Voice();
-      mine.write(`handles/${to}`, { face: minted.pack() });
-      return { address: Tools.address(minted.pk), nextPkHash: minted.nextPkHash };
-    },
-    release: async (to) => {
-      const gone = await send(to, { release: {} });
-      mine.write(`handles/${to}`, undefined);
-      return gone;
-    },
-    rights,
-    send,
-  });
-};
-
-const rotates = ({ mine }, from, nextPkHash) => {
-  const claim = Tools.digest(Tools.pkOf(from));
-  const held = mine
-    .list('refs/')
-    .map((key) => ({ key, referred: mine.read(key) }))
-    .find(({ referred }) => referred?.nextPkHash === claim);
-  if (
-    held === undefined ||
-    (held.key !== `refs/${from}` && mine.read(`refs/${from}`) !== undefined)
-  ) {
-    return undefined;
-  }
-  mine.write(`refs/${from}`, { nextPkHash, rights: held.referred.rights });
-  mine.write(held.key, undefined);
-  return from;
-};
-
-const SUCCESSION = 'chain/succession/';
-
-const successionOf = (memory, address) =>
-  memory
-    .list(address, SUCCESSION)
-    .map((key) => memory.read(address, key)?.value)
-    .filter((one) => one !== undefined)
-    .sort((one, other) => one.v - other.v);
-
-const Being = ({
-  voice,
-  address,
-  cipher,
-  deliver,
-  modules,
-  registry,
-  administration,
-  span,
-  vouched,
-  watch,
-}) => {
-  const held = spanOf(span);
-  const memory = modules.memory;
-  const root = rootFor({ memory, voice, address, cipher });
-  const source = memory.read(address, 'program')?.value;
-  const program = source === undefined ? undefined : Program(source);
-  const mine = Compartment({
-    memory,
-    voice,
-    address,
-    root,
-    classOf: (key) => program?.classOf(key) ?? coreClass(key),
-    cipher,
-  });
-  const succession = successionOf(memory, address);
-  const stamp = Stamp();
-  const seat = Object.freeze({ administration: administration === true, now: stamp });
-  const lanes = new Map();
-  const answer = (spoken, claim) => {
-    const body = Tools.canon(spoken);
-    if (body.length > MEASURE) {
-      return undefined;
-    }
-    const signed = { body: spoken, sig: voice.sign(Tools.canon({ body: spoken, claim })) };
-    return succession.length === 0 ? signed : { ...signed, succession };
-  };
-  const note = (envelope, outcome) => {
-    try {
-      watch?.(
-        Object.freeze({
-          from: envelope?.from,
-          kind: envelope?.op === undefined ? undefined : Object.keys(envelope.op)[0],
-          outcome,
-          to: envelope?.to,
-        }),
-      );
-    } catch {
-      return undefined;
-    }
-  };
-
-  return Object.freeze(async (envelope, token) => {
-    let gated;
-    const spoken = await (async () => {
-      try {
-        const { from, op, seq, sig, to } = envelope;
-        const claim = Tools.canon({ from, op, seq, to });
-        const claimDigest = Tools.digest(claim);
-        const callerPk = Tools.pkOf(from);
-        const proven =
-          claim.length <= MEASURE &&
-          callerPk !== null &&
-          ((vouched !== undefined && token === vouched) || Tools.verifies(callerPk, claim, sig));
-        if (to !== address || !proven) {
-          gated = 'unproven';
-          return undefined;
-        }
-        const self = from === Tools.address(voice.pk);
-        const row = self ? undefined : mine.read(`refs/${from}`);
-        if (row !== undefined && !(vouched !== undefined && token === vouched)) {
-          if (!(seq > (row.seen ?? 0))) {
-            gated = 'replayed';
-            return undefined;
-          }
-          mine.write(`refs/${from}`, { ...row, seen: seq });
-        }
-        const rights = self ? 'SELF' : (row?.rights ?? 'STRANGER');
-        if (op?.describe !== undefined) {
-          if (program !== undefined && !program.visible(rights)) {
-            return undefined;
-          }
-          return answer(
-            {
-              address,
-              box: Bytes.base64(voice.boxPk),
-              digest: program?.digest,
-              rights,
-              sdl: program?.sdlFor(rights),
-            },
-            claimDigest,
-          );
-        }
-        if (op?.introspect !== undefined) {
-          const seen = await program?.introspect(rights);
-          return seen === undefined ? undefined : answer({ introspection: seen }, claimDigest);
-        }
-        if (op?.rotate !== undefined) {
-          const rotated = rotates({ mine }, from, op.rotate.nextPkHash);
-          return rotated === undefined ? undefined : answer({ rotated }, claimDigest);
-        }
-        if (op?.release !== undefined) {
-          if (row === undefined) {
-            return undefined;
-          }
-          mine.write(`refs/${from}`, undefined);
-          return answer({ released: from }, claimDigest);
-        }
-        if (op?.acceptInvite !== undefined) {
-          const offer = Tools.digest(Bytes.unbase64(op.acceptInvite.proof));
-          const pending = mine.read(`refs/pending/${offer}`);
-          const now = stamp();
-          if (
-            pending === undefined ||
-            !(pending.count > 0) ||
-            (pending.expiresAt > 0 && now > pending.expiresAt)
-          ) {
-            return undefined;
-          }
-          mine.write(`refs/pending/${offer}`, { ...pending, count: pending.count - 1 });
-          mine.write(`refs/${from}`, {
-            nextPkHash: op.acceptInvite.nextPkHash ?? null,
-            rights: pending.rights,
-            seen: seq ?? 0,
-          });
-          return answer({ referred: from, rights: pending.rights }, claimDigest);
-        }
-        if (op?.ask === undefined || program === undefined || !program.visible(rights)) {
-          return undefined;
-        }
-        const fence = Fence();
-        const turn = fenced(mine, fence);
-        const asked = await within(
-          held,
-          program.ask({
-            context: {
-              from: program.caller ? from : undefined,
-              modules: offered(modules, program, turn, seat),
-              port: Port({ voice, mine: turn, deliver, fence, lanes, rights, stamp }),
-              registry: custodial(registry, fence),
-              rights,
-            },
-            source: op.ask.source,
-            variables: op.ask.variables,
-          }),
-        ).finally(fence.close);
-        return asked === undefined ? undefined : answer(asked, claimDigest);
-      } catch {
-        return undefined;
-      }
-    })();
-    note(envelope, gated ?? (spoken === undefined ? 'mute' : 'answered'));
-    return spoken;
-  });
-};
-
-// VII: the chain takes no plain write above version 1, so its rows stand.
-const spend = ({ memory, voice, address }) => {
-  for (const key of memory.list(address, '')) {
-    const cell = key.startsWith('chain/') ? undefined : memory.read(address, key);
-    if (cell === undefined || cell.value === null) {
-      continue;
-    }
-    const claim = { address, key, value: null, version: cell.version + 1 };
-    memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) });
-  }
-  return address;
-};
-
-const make = ({ memory, voice, address, program, cipher }) => {
-  const root = Tools.secret();
-  const put = (key, value) => {
-    const claim = { address, key, value, version: (memory.read(address, key)?.version ?? 0) + 1 };
-    return memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) });
-  };
-  put('chain/pk', Bytes.hex(voice.pk));
-  put('chain/nextPkHash', voice.nextPkHash);
-  put('program', program ?? '({})');
-  put(`keyring/${Tools.address(voice.pk)}`, {
-    boxPk: Bytes.base64(voice.boxPk),
-    wrapped: Voice.sealTo(voice.boxPk, Bytes.base64(root), cipher),
-  });
-  const written = program === undefined ? undefined : Program(program);
-  return Compartment({
-    memory,
-    voice,
-    address,
-    root,
-    classOf: (key) => written?.classOf(key) ?? coreClass(key),
-    cipher,
-  });
-};
-
-const Registry = ({
-  memory,
-  adminMine,
-  address,
-  cipher,
-  deliver,
-  modules,
-  modulesFor,
-  announce,
-  forget,
-  span,
-  vouched,
-  attest,
-  watch,
-  extended,
-}) => {
-  const live = new Map();
-  const stranded = (at, written) => {
-    const source = memory.read(at, 'program')?.value;
-    const standing = source === undefined ? undefined : Program(source);
-    return memory
-      .list(at, '')
-      .filter((key) => memory.read(at, key)?.value !== null)
-      .filter((key) => {
-        const under = written.classOf(key);
-        const was = standing?.classOf(key) ?? coreClass(key);
-        return under === undefined || (was !== undefined && was !== under);
-      });
-  };
-  const activate = (at) => {
-    if (live.has(at)) {
-      return live.get(at);
-    }
-    const held = adminMine.read(`identity/custody/${at}`);
-    const voice = held === undefined ? undefined : Voice.revive(held);
-    if (voice === undefined) {
-      return undefined;
-    }
-    const declared = (Program(memory.read(at, 'program')?.value)?.modules ?? []).map(
-      (one) => one.module,
-    );
-    const door = Being({
-      address: at,
-      cipher,
-      deliver,
-      modules: modulesFor(voice, declared),
-      span,
-      vouched,
-      voice,
-      watch,
-    });
-    live.set(at, door);
-    return door;
-  };
-  return Object.freeze({
-    activate,
-    attest,
-    create: ({ program, refs = [], data = {}, bindings, config } = {}) => {
-      const written = program === undefined ? undefined : Program(program);
-      if (program !== undefined && written === undefined) {
-        return undefined;
-      }
-      const missing = (written?.modules ?? []).filter((one) => !modules.has(one.module));
-      if (missing.length > 0) {
-        return undefined;
-      }
-      const brought = written?.bindings(bindings);
-      const settings = written?.config(config);
-      if (written !== undefined && (brought === undefined || settings === undefined)) {
-        return undefined;
-      }
-      const allowed = grantable(written);
-      if (refs.some((ref) => !allowed.includes(ref.rights ?? 'MEMBER'))) {
-        return undefined;
-      }
-      if (refs.some((ref) => typeof ref.address !== 'string' || Tools.pkOf(ref.address) === null)) {
-        return undefined;
-      }
-      const voice = Voice();
-      const address = Tools.address(voice.pk);
-      const mine = make({ memory, voice, address, program, cipher });
-      for (const [key, value] of Object.entries(data)) {
-        if (mine.write(key, value) === undefined) {
-          forget(address);
-          return undefined;
-        }
-      }
-      if (written !== undefined) {
-        mine.write('config', settings);
-        for (const [module, bound] of Object.entries(brought)) {
-          mine.write(`bindings/${module}`, bound);
-        }
-      }
-      for (const ref of refs) {
-        mine.write(`refs/${ref.address}`, {
-          nextPkHash: ref.nextPkHash ?? null,
-          rights: ref.rights ?? 'MEMBER',
-        });
-      }
-      adminMine.write(`identity/custody/${address}`, voice.pack());
-      announce(address);
-      return address;
-    },
-    deactivate: (at) => live.delete(at),
-    extend: (source) => {
-      const program = source === undefined || source === null ? ADMIN : composed(ADMIN, source);
-      const written = program === undefined ? undefined : Program(program);
-      if (written === undefined) {
-        return undefined;
-      }
-      if (written.modules.some((one) => !modules.has(one.module))) {
-        return undefined;
-      }
-      if (stranded(address, written).length > 0) {
-        return undefined;
-      }
-      if (adminMine.write('program', program) === undefined) {
-        return undefined;
-      }
-      extended?.();
-      return address;
-    },
-    upgrade: ({ address: target, program }) => {
-      if (target === address) {
-        return undefined;
-      }
-      const written = program === undefined ? undefined : Program(program);
-      if (written === undefined) {
-        return undefined;
-      }
-      if (stranded(target, written).length > 0) {
-        return undefined;
-      }
-      const held = adminMine.read(`identity/custody/${target}`);
-      const voice = held === undefined ? undefined : Voice.revive(held);
-      if (voice === undefined) {
-        return undefined;
-      }
-      const claim = {
-        address: target,
-        key: 'program',
-        value: program,
-        version: (memory.read(target, 'program')?.version ?? 0) + 1,
-      };
-      if (memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) }) === undefined) {
-        return undefined;
-      }
-      live.delete(target);
-      return target;
-    },
-    destroy: (at) => {
-      const held = adminMine.read(`identity/custody/${at}`);
-      const voice = held === undefined ? undefined : Voice.revive(held);
-      if (voice === undefined) {
-        return undefined;
-      }
-      adminMine.write(`identity/custody/${at}`, undefined);
-      live.delete(at);
-      forget(at, voice);
-      return at;
-    },
-    residents: () => {
-      const aliasFor = new Map();
-      for (const key of adminMine.list('aliases/')) {
-        const named = adminMine.read(key);
-        if (typeof named === 'string') {
-          aliasFor.set(named, key.slice('aliases/'.length));
-        }
-      }
-      return adminMine.list('identity/custody/').map((key) => {
-        const at = key.slice('identity/custody/'.length);
-        const digest = Program(memory.read(at, 'program')?.value)?.digest ?? null;
-        return {
-          address: at,
-          alias: aliasFor.get(at) ?? null,
-          active: live.has(at),
-          digest,
-        };
-      });
-    },
-  });
-};
-
-export { Being, Compartment, Registry, SUCCESSION, make, rootFor, spend, successionOf };