nervur 0.14.0 → 0.16.0

package/ground.mjs

@@ -1,382 +0,0 @@
-import { ADMIN } from './admin.mjs';
-import {
-  Being,
-  Compartment,
-  Registry,
-  SUCCESSION,
-  make,
-  rootFor,
-  spend,
-  successionOf,
-} from './being.mjs';
-import { Blueprint, composed, coreClass } from './blueprint.mjs';
-import { Client } from './client.mjs';
-import { Contracts } from './contract.mjs';
-import { Memory } from './modules.mjs';
-import { Mcp, Pointer } from './pointer.mjs';
-import { Program } from './program.mjs';
-import { Bytes, Stamp, Tools } from './tools.mjs';
-import { Voice } from './voice.mjs';
-
-const GROUND = 'Ground';
-
-const FLOOR = [
-  'blueprints',
-  'cells',
-  'cipher',
-  'contracts',
-  'keychain',
-  'moved',
-  'paths',
-  'watch',
-  'wire',
-];
-
-const UNPROVEN = 'ground/unproven/';
-
-const HEIR = 'ground/heir';
-
-const commits = (cells, bundle) => {
-  const boxPk = bundle?.heirBoxPk;
-  try {
-    if (typeof boxPk !== 'string' || Bytes.unbase64(boxPk).length !== 32) {
-      return undefined;
-    }
-  } catch {
-    return undefined;
-  }
-  cells.put(HEIR, { boxPk, nextPkHash: bundle.nextPkHash });
-  return undefined;
-};
-
-const unprovenAt = (cells) => (at) => {
-  try {
-    const stood = cells.peek(`${UNPROVEN}${at}`);
-    const seen = Date.now();
-    cells.put(`${UNPROVEN}${at}`, {
-      at,
-      last: seen,
-      seen: (stood?.seen ?? 0) + 1,
-      since: stood?.since ?? seen,
-    });
-  } catch {
-    return undefined;
-  }
-};
-
-const unprovenRows = (cells) => cells.keys(UNPROVEN).map((row) => cells.peek(row));
-
-const install = ({ cells, keychain, program, bundle, cipher }) => {
-  if (cells.peek('ground/admin') !== undefined || bundle?.next !== undefined) {
-    return undefined;
-  }
-  const voice = Voice.revive(bundle ?? {});
-  if (voice === undefined) {
-    return undefined;
-  }
-  const memory = Memory(cells);
-  const address = Tools.address(voice.pk);
-  const sealed = keychain.seal(voice.pack());
-  if (sealed === undefined) {
-    return undefined;
-  }
-  make({ memory, voice, address, program, cipher });
-  cells.put('ground/admin', { address, sealed });
-  commits(cells, bundle);
-  return address;
-};
-
-const succeeds = ({ adminMine, adminVoice, address, bundle, cells, cipher, keychain, memory }) => {
-  if (bundle?.next !== undefined) {
-    return undefined;
-  }
-  const heir = Voice.revive(bundle ?? {});
-  const committed = memory.read(address, 'chain/nextPkHash');
-  if (heir === undefined || committed?.value !== Tools.digest(heir.pk)) {
-    return undefined;
-  }
-  const root = rootFor({ memory, voice: adminVoice, address, cipher });
-  const sealed = root === undefined ? undefined : keychain.seal(heir.pack());
-  if (sealed === undefined) {
-    return undefined;
-  }
-  const rewrapped = adminMine.write(`keyring/${Tools.address(heir.pk)}`, {
-    boxPk: Bytes.base64(heir.boxPk),
-    wrapped: Voice.sealTo(heir.boxPk, Bytes.base64(root), cipher),
-  });
-  if (rewrapped === undefined) {
-    return undefined;
-  }
-  const version = committed.version + 1;
-  const certV = successionOf(memory, address).length + 1;
-  const handover = { at: address, next: Tools.address(heir.pk), v: certV };
-  const certified = adminMine.write(`${SUCCESSION}${certV}`, {
-    ...handover,
-    sig: adminVoice.sign(Tools.canon(handover)),
-  });
-  if (certified === undefined) {
-    return undefined;
-  }
-  const claim = {
-    address,
-    nextPkHash: heir.nextPkHash,
-    pk: Bytes.hex(heir.pk),
-    version,
-  };
-  if (memory.replace({ ...claim, sig: heir.sign(Tools.canon(claim)) }) === undefined) {
-    return undefined;
-  }
-  cells.put('ground/admin', { address, sealed });
-  commits(cells, bundle);
-  return Tools.address(heir.pk);
-};
-
-// Never a key in the modules object: everything there that is not in FLOOR
-// becomes a module handed to programs under that name.
-const Ground = (modules = {}, { span } = {}) => {
-  const cells = modules.cells;
-  const keychain = modules.keychain;
-  const cipher = modules.cipher;
-  if (
-    cells === undefined ||
-    keychain?.seal === undefined ||
-    keychain?.unseal === undefined ||
-    cipher?.seal === undefined ||
-    cipher?.unseal === undefined
-  ) {
-    return undefined;
-  }
-
-  const written = modules.contracts ?? Contracts({});
-  const extra = Object.fromEntries(
-    Object.entries(modules).filter(([name]) => !FLOOR.includes(name)),
-  );
-  const bound = Object.entries(extra).filter(([, one]) => one?.at !== undefined);
-  if (bound.some(([, one]) => !written.has(one.contract))) {
-    return undefined;
-  }
-
-  const extension = modules.blueprints?.ground();
-  const program = extension === undefined ? ADMIN : composed(ADMIN, extension);
-  const blueprint = program === undefined ? undefined : Blueprint(program);
-  if (blueprint?.digest === undefined) {
-    return undefined;
-  }
-  const installed = cells.peek('ground/admin');
-  if (installed === undefined) {
-    return Object.freeze({
-      init: (bundle) => install({ cells, keychain, program, bundle, cipher: modules.cipher }),
-    });
-  }
-  const bundle = keychain.unseal(installed.sealed);
-  const adminVoice = bundle === undefined ? undefined : Voice.revive(bundle);
-  if (adminVoice === undefined) {
-    return undefined;
-  }
-
-  // Never leaves this closure — nothing outside may be handed it.
-  const vouched = Symbol('vouched');
-
-  const watch = (fact) => {
-    try {
-      modules.watch?.(Object.freeze(fact));
-    } catch {
-      return undefined;
-    }
-  };
-
-  const address = installed.address;
-  const memory = Memory(cells, unprovenAt(cells), modules.moved);
-  const paths = modules.paths ?? Object.freeze({ find: () => undefined, publish: () => undefined });
-  const wire =
-    modules.wire ??
-    Object.freeze({
-      carry: async (endpoint, envelope) =>
-        typeof endpoint === 'function' ? endpoint(envelope) : undefined,
-    });
-
-  const stamp = Stamp();
-  const boundFor = (voice) =>
-    Object.fromEntries(
-      bound.map(([name, one]) => [
-        name,
-        Pointer(written.get(one.contract).sdl, async (source, variables) =>
-          deliver(await Tools.envelope(voice, one.at, { ask: { source, variables } }, stamp())),
-        ),
-      ]),
-    );
-  const introduced = (unscoped, address) =>
-    Object.fromEntries(
-      Object.entries(unscoped).map(([name, one]) => [
-        name,
-        typeof one?.scope === 'function' ? one.scope(address) : one,
-      ]),
-    );
-  const declaredOnly = (obj, declared) =>
-    Object.fromEntries(Object.entries(obj).filter(([name]) => declared.includes(name)));
-  const modulesFor = (voice, declared = []) =>
-    Object.freeze(
-      introduced(
-        {
-          ...declaredOnly(extra, declared),
-          ...declaredOnly(boundFor(voice), declared),
-          memory,
-        },
-        Tools.address(voice.pk),
-      ),
-    );
-  const offeredNames = new Set([...Object.keys(extra), ...bound.map(([name]) => name), 'memory']);
-  const adminDeclared = () =>
-    (Program(memory.read(address, 'program')?.value)?.modules ?? blueprint.modules).map(
-      (one) => one.module,
-    );
-
-  const adminMine = Compartment({
-    memory,
-    voice: adminVoice,
-    address,
-    root: rootFor({ memory, voice: adminVoice, address, cipher: modules.cipher }),
-    classOf: (key) =>
-      Program(memory.read(address, 'program')?.value)?.classOf(key) ?? coreClass(key),
-    cipher: modules.cipher,
-  });
-
-  const receive = async (envelope, token) => {
-    const at = envelope?.to;
-    const door = at === address ? admin : registry.activate(at);
-    if (door === undefined) {
-      watch({
-        from: envelope?.from,
-        kind: envelope?.op === undefined ? undefined : Object.keys(envelope.op)[0],
-        outcome: 'no-door',
-        to: at,
-      });
-      return undefined;
-    }
-    return door(envelope, token);
-  };
-  const announce = (at) => paths.publish(at, receive);
-  const forget = (at, voice) => {
-    paths.publish(at, undefined);
-    if (voice === undefined) {
-      cells.drop(`${at}/`);
-      modules.moved?.(at);
-      return undefined;
-    }
-    return spend({ memory, voice, address: at });
-  };
-
-  const attest = async (name) => {
-    const one = extra[name];
-    if (one === undefined) {
-      return false;
-    }
-    if (one.at === undefined) {
-      return null;
-    }
-    const seen = await deliver(await Tools.envelope(adminVoice, one.at, { describe: {} }, stamp()));
-    return seen?.body?.sdl === undefined
-      ? false
-      : written.get(one.contract).satisfies(seen.body.sdl);
-  };
-
-  let adminDoor;
-  const buildAdmin = () =>
-    Being({
-      address,
-      administration: true,
-      cipher: modules.cipher,
-      deliver: (envelope) => deliver(envelope),
-      modules: modulesFor(adminVoice, adminDeclared()),
-      registry,
-      span,
-      vouched,
-      voice: adminVoice,
-      watch,
-    });
-  const registry = Registry({
-    memory,
-    adminMine,
-    address,
-    cipher: modules.cipher,
-    deliver: (envelope) => deliver(envelope),
-    modules: offeredNames,
-    modulesFor,
-    announce,
-    forget,
-    span,
-    vouched,
-    attest,
-    watch,
-    extended: () => {
-      adminDoor = undefined;
-    },
-  });
-  const admin = (envelope, token) => {
-    if (adminDoor === undefined) {
-      adminDoor = buildAdmin();
-    }
-    return adminDoor(envelope, token);
-  };
-
-  announce(address);
-  for (const key of adminMine.list('identity/custody/')) {
-    announce(key.slice('identity/custody/'.length));
-  }
-
-  const held = (at) => at === address || adminMine.read(`identity/custody/${at}`) !== undefined;
-  const deliver = async (envelope) =>
-    held(envelope.to) ? receive(envelope, vouched) : wire.carry(paths.find(envelope.to), envelope);
-
-  // Client edge only — a resolver must never be handed this.
-  const resolve = (one) => (one === GROUND ? address : (adminMine.read(`aliases/${one}`) ?? one));
-
-  return Object.freeze({
-    address,
-    receive,
-    rotate: (bundle) =>
-      succeeds({
-        adminMine,
-        adminVoice,
-        address,
-        bundle,
-        cells,
-        cipher: modules.cipher,
-        keychain,
-        memory,
-      }),
-    serve: (voice) => {
-      const client = Client({ voice, deliver, resolve });
-      const sdlOf = async (at) => (await client.describe(at))?.body?.sdl;
-      const asker = (at) => (source, variables) => client.ask(at, source, variables);
-      return Object.freeze({
-        address: client.address,
-        client,
-        gql: (at) =>
-          Object.freeze({
-            ask: asker(at),
-            introspect: () => client.introspect(at),
-            sdl: () => sdlOf(at),
-          }),
-        mcp: async (at) => {
-          const sdl = await sdlOf(at);
-          return sdl === undefined ? undefined : Mcp(sdl, asker(at));
-        },
-        pointer: async (at) => {
-          const sdl = await sdlOf(at);
-          return sdl === undefined ? undefined : Pointer(sdl, asker(at));
-        },
-      });
-    },
-    seated: (at, from) => {
-      if (at === from) {
-        return true;
-      }
-      const row = held(at) ? memory.read(at, `refs/${from}`)?.value : undefined;
-      return row !== undefined && row !== null;
-    },
-    unproven: () => unprovenRows(cells),
-  });
-};
-
-export { FLOOR, GROUND, Ground };

package/index.mjs

@@ -1,20 +0,0 @@
-export { ADMIN } from './admin.mjs';
-export {
-  Blueprint,
-  CLASSES,
-  CORE_ONLY,
-  OPEN,
-  STRUCTURAL,
-  composition,
-  coreClass,
-  faults,
-  reads,
-} from './blueprint.mjs';
-export { Client, speaking } from './client.mjs';
-export { Contract, Contracts } from './contract.mjs';
-export { FLOOR, GROUND, Ground } from './ground.mjs';
-export { Memory } from './modules.mjs';
-export { Mcp, Pointer } from './pointer.mjs';
-export { Program } from './program.mjs';
-export { Bytes, MEASURE, SPAN, Stamp, Tools } from './tools.mjs';
-export { Voice } from './voice.mjs';

package/modules.mjs

@@ -1,55 +0,0 @@
-import { Bytes, Tools } from './tools.mjs';
-
-// The ground's own machinery over its cells. Every implementation a host
-// supplies — cells, keychain, cipher, paths, wire — belongs to that host's
-// floor and never to the core (X, Everything is a module).
-const Memory = (cells, unproven, moved) => {
-  const held = (address, key) => cells.peek(`${address}/${key}`);
-  const writerAt = (address) => {
-    const chain = held(address, 'chain/pk');
-    return chain === undefined ? Tools.pkOf(address) : Bytes.unhex(chain.value);
-  };
-  return Object.freeze({
-    list: (address, prefix) =>
-      cells.keys(`${address}/${prefix}`).map((cell) => cell.slice(address.length + 1)),
-
-    read: (address, key) => held(address, key),
-
-    replace: ({ address, pk, nextPkHash, sig }) => {
-      const committed = held(address, 'chain/nextPkHash');
-      if (committed === undefined || Tools.digest(Bytes.unhex(pk)) !== committed.value) {
-        return undefined;
-      }
-      const version = committed.version + 1;
-      const claim = { address, nextPkHash, pk, version };
-      if (!Tools.verifies(Bytes.unhex(pk), Tools.canon(claim), sig)) {
-        return undefined;
-      }
-      cells.put(`${address}/chain/pk`, { value: pk, version });
-      cells.put(`${address}/chain/nextPkHash`, { value: nextPkHash, version });
-      moved?.(address);
-      return version;
-    },
-
-    write: ({ address, key, value, version, sig }) => {
-      if (key.startsWith('chain/') && version !== 1) {
-        return undefined;
-      }
-      const writer = writerAt(address);
-      if (writer === null || version !== (held(address, key)?.version ?? 0) + 1) {
-        return undefined;
-      }
-      if (!Tools.verifies(writer, Tools.canon({ address, key, value, version }), sig)) {
-        unproven?.(address);
-        return undefined;
-      }
-      cells.put(`${address}/${key}`, { value, version });
-      if (!key.startsWith('refs/')) {
-        moved?.(address);
-      }
-      return version;
-    },
-  });
-};
-
-export { Memory };

package/pointer.mjs

@@ -1,79 +0,0 @@
-import { buildSchema, getNamedType, isAbstractType, isObjectType } from 'graphql';
-
-const JSON_TYPE = { Boolean: 'boolean', Float: 'number', ID: 'string', Int: 'integer' };
-
-const selection = (type, depth) => {
-  const named = getNamedType(type);
-  if (!isObjectType(named) || depth === 0) {
-    return '';
-  }
-  const fields = Object.values(named.getFields())
-    .filter(
-      (one) =>
-        !one.args.some((arg) => String(arg.type).endsWith('!') && arg.defaultValue === undefined),
-    )
-    .filter((one) => !isAbstractType(getNamedType(one.type)))
-    .filter((one) => depth > 1 || !isObjectType(getNamedType(one.type)))
-    .map((one) => `${one.name}${selection(one.type, depth - 1)}`);
-  return fields.length === 0 ? '' : ` { ${fields.join(' ')} }`;
-};
-
-const document = (kind, field, args) => {
-  const used = field.args.filter((one) => args[one.name] !== undefined);
-  const names = used.map((one) => `$${one.name}: ${one.type}`).join(', ');
-  const pass = used.map((one) => `${one.name}: $${one.name}`).join(', ');
-  return `${kind}${names ? `(${names})` : ''} { ${field.name}${
-    pass ? `(${pass})` : ''
-  }${selection(field.type, 3)} }`;
-};
-
-const roots = (schema) =>
-  ['query', 'mutation'].flatMap((kind) => {
-    const type = kind === 'query' ? schema.getQueryType() : schema.getMutationType();
-    return type === undefined || type === null
-      ? []
-      : Object.values(type.getFields()).map((field) => ({ field, kind }));
-  });
-
-const calls = (sdl, ask) => {
-  const schema = buildSchema(sdl);
-  return roots(schema).map(({ field, kind }) => ({
-    field,
-    kind,
-    run: async (args = {}) => {
-      const answered = await ask(document(kind, field, args), args);
-      return answered?.body?.data?.[field.name];
-    },
-  }));
-};
-
-const Pointer = (sdl, ask) =>
-  Object.freeze(Object.fromEntries(calls(sdl, ask).map((one) => [one.field.name, one.run])));
-
-const Mcp = (sdl, ask) => {
-  const held = calls(sdl, ask);
-  return Object.freeze({
-    call: (name, args) => held.find((one) => one.field.name === name)?.run(args),
-    tools: held.map(({ field, kind }) =>
-      Object.freeze({
-        annotations: { readOnlyHint: kind === 'query' },
-        description: field.description ?? undefined,
-        inputSchema: {
-          properties: Object.fromEntries(
-            field.args.map((one) => [
-              one.name,
-              { type: JSON_TYPE[getNamedType(one.type).name] ?? 'string' },
-            ]),
-          ),
-          required: field.args
-            .filter((one) => String(one.type).endsWith('!'))
-            .map((one) => one.name),
-          type: 'object',
-        },
-        name: field.name,
-      }),
-    ),
-  });
-};
-
-export { Mcp, Pointer };

package/program.mjs

@@ -1,119 +0,0 @@
-import {
-  buildSchema,
-  defaultFieldResolver,
-  getIntrospectionQuery,
-  graphql,
-  isObjectType,
-  parse,
-  validate,
-} from 'graphql';
-import { Blueprint } from './blueprint.mjs';
-
-const bound = (blueprint) => {
-  const schema = blueprint.schema;
-  for (const type of Object.values(schema.getTypeMap())) {
-    if (!isObjectType(type) || type.name.startsWith('__')) {
-      continue;
-    }
-    for (const [field, held] of Object.entries(type.getFields())) {
-      const resolver = blueprint.resolvers[type.name]?.[field] ?? defaultFieldResolver;
-      held.resolve = (source, args, context, info) =>
-        blueprint.admits(type.name, field, context.rights)
-          ? resolver(source, args, context, info)
-          : null;
-    }
-  }
-  return schema;
-};
-
-const Program = (source) => {
-  const blueprint = Blueprint(source);
-  if (blueprint === undefined || blueprint.trespass.length > 0) {
-    return undefined;
-  }
-  const schema = bound(blueprint);
-  const curtained = new Map();
-  const seenBy = (held) => {
-    if (!curtained.has(held)) {
-      try {
-        curtained.set(held, buildSchema(blueprint.sdlFor(held)));
-      } catch {
-        curtained.set(held, undefined);
-      }
-    }
-    return curtained.get(held);
-  };
-  // graphql's validator demands a Query root even to judge a mutation, so an
-  // all-mutation filtered world validates against a copy wearing an empty one
-  // — never printed, never executed against.
-  const askable = new Map();
-  const askableBy = (held) => {
-    if (!askable.has(held)) {
-      const seen = seenBy(held);
-      try {
-        askable.set(
-          held,
-          seen === undefined || seen.getQueryType() != null
-            ? seen
-            : buildSchema(`${blueprint.sdlFor(held)}\ntype Query { _stands: Boolean }`),
-        );
-      } catch {
-        askable.set(held, undefined);
-      }
-    }
-    return askable.get(held);
-  };
-  return Object.freeze({
-    ask: async ({ source: asked, variables, context }) => {
-      const seen = askableBy(context.rights);
-      if (seen === undefined) {
-        return undefined;
-      }
-      try {
-        if (validate(seen, parse(asked)).length > 0) {
-          return undefined;
-        }
-      } catch {
-        return undefined;
-      }
-      const answered = await graphql({
-        contextValue: context,
-        schema,
-        source: asked,
-        variableValues: variables,
-      });
-      return answered.errors === undefined ? { data: answered.data } : undefined;
-    },
-    bindings: blueprint.bindings,
-    caller: blueprint.caller,
-    classOf: blueprint.classOf,
-    config: blueprint.config,
-    declares: blueprint.declares,
-    digest: blueprint.digest,
-    invites: blueprint.invites,
-    introspect: async (held) => {
-      const filtered = seenBy(held);
-      if (filtered === undefined) {
-        return undefined;
-      }
-      const answered = await graphql({ schema: filtered, source: getIntrospectionQuery() });
-      return answered.errors === undefined ? answered.data : undefined;
-    },
-    modules: blueprint.modules,
-    name: blueprint.name,
-    rights: blueprint.rights,
-    sdlFor: blueprint.sdlFor,
-    visible: (held) => {
-      const filtered = seenBy(held);
-      if (filtered === undefined) {
-        return false;
-      }
-      const rooted = [filtered.getQueryType(), filtered.getMutationType()].filter(
-        (one) => one !== undefined && one !== null,
-      );
-      return rooted.some((one) => Object.keys(one.getFields()).length > 0);
-    },
-  });
-};
-
-export { Program };