nervur 0.14.0 → 0.16.0

package/blueprint.mjs

@@ -1,512 +0,0 @@
-import { Kind, buildSchema, coerceInputValue, parse, print } from 'graphql';
-import { Tools } from './tools.mjs';
-
-const STRUCTURAL = ['SELF', 'STRANGER'];
-
-const CLASSES = [
-  'bindings',
-  'chain',
-  'config',
-  'data',
-  'handles',
-  'identity',
-  'keyring',
-  'program',
-  'refs',
-];
-
-const OPEN = ['chain', 'keyring', 'program'];
-
-const CORE_ONLY = ['chain', 'identity', 'keyring', 'program'];
-
-const CORE = [
-  ['chain/', 'chain'],
-  ['keyring/', 'keyring'],
-  ['refs/', 'refs'],
-  ['handles/', 'handles'],
-  ['bindings/', 'bindings'],
-  ['identity/', 'identity'],
-  ['config', 'config'],
-  ['program', 'program'],
-];
-
-const coreClass = (key) =>
-  CORE.find(([mark]) => (mark.endsWith('/') ? key.startsWith(mark) : key === mark))?.[1];
-
-const declaredClass = (memory, key) => {
-  const held = memory[key];
-  if (held !== undefined) {
-    return held.class;
-  }
-  const under = Object.keys(memory)
-    .filter((one) => one.endsWith('/*'))
-    .find((one) => key.startsWith(one.slice(0, -1)));
-  return under === undefined ? undefined : memory[under].class;
-};
-
-const AMBIENT = [
-  'globalThis',
-  'process',
-  'require',
-  'import',
-  'eval',
-  'Function',
-  'fetch',
-  'XMLHttpRequest',
-  'WebAssembly',
-  'SharedArrayBuffer',
-  'Atomics',
-  'Buffer',
-  'crypto',
-  'Date',
-  'setTimeout',
-  'setInterval',
-  'queueMicrotask',
-];
-
-const REACHES = [
-  ['constructor', /\bconstructor\b/],
-  ['__proto__', /\b__proto__\b/],
-  ['prototype', /\bprototype\b/],
-  ['Math.random', /\bMath\s*\.\s*random\b/],
-];
-
-const FORBIDDEN = [
-  ...AMBIENT.map((name) => [name, new RegExp(`(?<![.$\\w])${name}\\b(?!\\s*:)`)]),
-  ...REACHES,
-];
-
-const RESERVED = ['eval', 'import', '__proto__', 'prototype', 'Math.random'];
-
-const SHADOWED = FORBIDDEN.map(([name]) => name).filter((name) => !RESERVED.includes(name));
-
-const doorHolder = (one) =>
-  one.kind === Kind.OBJECT_TYPE_DEFINITION || one.kind === Kind.OBJECT_TYPE_EXTENSION;
-
-const RIGHTS_DIRECTIVE = 'directive @rights(is: [Rights!]!) on FIELD_DEFINITION';
-
-const INVITES_DIRECTIVE = 'directive @invites(count: Int!, within: Int!) on ENUM_VALUE';
-
-const DEFAULT_RIGHTS = `enum Rights { SELF MEMBER STRANGER }`;
-
-const codeOnly = (source) => {
-  const out = [];
-  const modes = [{ depth: 0, kind: 'code' }];
-  let at = 0;
-  while (at < source.length) {
-    const mode = modes[modes.length - 1];
-    const one = source[at];
-    if (mode.kind !== 'code') {
-      if (one === '\\') {
-        out.push('  ');
-        at += 2;
-      } else if (one === mode.mark) {
-        modes.pop();
-        out.push(' ');
-        at += 1;
-      } else if (mode.kind === 'template' && one === '$' && source[at + 1] === '{') {
-        modes.push({ depth: 0, kind: 'code' });
-        out.push('  ');
-        at += 2;
-      } else {
-        out.push(one === '\n' ? '\n' : ' ');
-        at += 1;
-      }
-      continue;
-    }
-    if (one === "'" || one === '"') {
-      modes.push({ kind: 'quote', mark: one });
-    } else if (one === '`') {
-      modes.push({ kind: 'template', mark: '`' });
-    } else if (one === '{') {
-      mode.depth += 1;
-    } else if (one === '}' && mode.depth === 0 && modes.length > 1) {
-      modes.pop();
-      out.push(' ');
-      at += 1;
-      continue;
-    } else if (one === '}') {
-      mode.depth -= 1;
-    }
-    out.push(one === "'" || one === '"' || one === '`' ? ' ' : one);
-    at += 1;
-  }
-  return out.join('');
-};
-
-const reads = (source) => {
-  const code = codeOnly(source);
-  return FORBIDDEN.filter(([, mark]) => mark.test(code)).map(([name]) => name);
-};
-
-const evaluated = (source) => {
-  const body = `"use strict"; return (${source});`;
-  return new Function(...SHADOWED, body)(...SHADOWED.map(() => undefined));
-};
-
-const rightsOf = (field) => {
-  const marked = field.directives?.find((one) => one.name.value === 'rights');
-  const listed = marked?.arguments?.find((one) => one.name.value === 'is');
-  return listed === undefined
-    ? undefined
-    : listed.value.values.map((one) => one.value ?? one.name?.value);
-};
-
-const whole = (one) => Number.isSafeInteger(one) && one >= 0;
-
-const ceilingOf = (value) => {
-  const marked = value.directives?.find((one) => one.name.value === 'invites');
-  if (marked === undefined) {
-    return undefined;
-  }
-  const argOf = (name) => {
-    const given = marked.arguments?.find((one) => one.name.value === name)?.value?.value;
-    return given === undefined ? undefined : Number(given);
-  };
-  return { count: argOf('count'), within: argOf('within') };
-};
-
-const ceilingsIn = (document) =>
-  new Map(
-    document.definitions
-      .filter((one) => one.kind === Kind.ENUM_TYPE_DEFINITION && one.name.value === 'Rights')
-      .flatMap((one) => one.values ?? [])
-      .map((value) => [value.name.value, ceilingOf(value)])
-      .filter(([, ceiling]) => ceiling !== undefined)
-      .map(([name, ceiling]) => [name, Object.freeze(ceiling)]),
-  );
-
-const resolverSources = (resolvers) =>
-  Object.keys(resolvers)
-    .sort()
-    .flatMap((type) =>
-      Object.keys(resolvers[type])
-        .sort()
-        .map((field) => `${type}.${field}=${resolvers[type][field].toString()}`),
-    );
-
-const merged = (base, added) =>
-  Object.fromEntries(
-    [...new Set([...Object.keys(base ?? {}), ...Object.keys(added ?? {})])].map((key) => [
-      key,
-      { ...(base ?? {})[key], ...(added ?? {})[key] },
-    ]),
-  );
-
-// Bare names, not Type.field pairs: X's "if create answers, it created"
-// makes Query.create and Mutation.create one reserved word.
-const doorsIn = (sdl) =>
-  parse(sdl)
-    .definitions.filter((one) => doorHolder(one) && ['Mutation', 'Query'].includes(one.name.value))
-    .flatMap((one) => (one.fields ?? []).map((field) => field.name.value));
-
-const rootsIn = (document, schema) => {
-  const roots = [
-    schema.getQueryType()?.name,
-    schema.getMutationType()?.name,
-    schema.getSubscriptionType()?.name,
-  ].filter((one) => one !== undefined);
-  return document.definitions
-    .filter((one) => doorHolder(one) && roots.includes(one.name.value))
-    .flatMap((one) => one.fields ?? []);
-};
-
-// Names why Blueprint would refuse; Blueprint itself rules, and never reads
-// this. The bench binds the two: every cause named here is one it refuses.
-const faults = (source) => {
-  const trespass = reads(source);
-  if (trespass.length > 0) {
-    return [`it reads ambient power no blueprint may hold: ${trespass.join(', ')} (VIII)`];
-  }
-  let written;
-  try {
-    written = evaluated(source);
-  } catch (error) {
-    return [`it is not an expression settling a blueprint object: ${error.message} (VIII)`];
-  }
-  if (written === null || typeof written !== 'object') {
-    return ['it settles no blueprint object (VIII)'];
-  }
-  const declares = /enum\s+Rights\b/.test(written.interface) ? '' : DEFAULT_RIGHTS;
-  const sdl = [RIGHTS_DIRECTIVE, INVITES_DIRECTIVE, declares, written.interface]
-    .filter(Boolean)
-    .join('\n');
-  let document;
-  let schema;
-  try {
-    document = parse(sdl);
-    schema = buildSchema(sdl);
-  } catch (error) {
-    return [`its schema does not compile: ${error.message} (VIII)`];
-  }
-  const declaredNames = (schema.getType('Rights')?.getValues() ?? []).map((one) => one.name);
-  const rights = [...new Set([...STRUCTURAL, ...declaredNames])];
-  const found = [];
-  if (!declares && STRUCTURAL.some((one) => !declaredNames.includes(one))) {
-    found.push(
-      `the Rights enum does not name ${STRUCTURAL.filter((one) => !declaredNames.includes(one)).join(', ')}, and every Rights enum names both SELF and STRANGER (VI)`,
-    );
-  }
-  for (const [key, cell] of Object.entries(written.memory ?? {})) {
-    if (coreClass(key) !== undefined) {
-      found.push(`the cell ${key} is the core's own, and no program declares it (VIII)`);
-    } else if (!CLASSES.includes(cell?.class)) {
-      found.push(`the cell ${key} names no class the memory law holds: ${cell?.class} (VIII)`);
-    }
-  }
-  const bare = [];
-  const outside = new Map();
-  for (const field of rootsIn(document, schema)) {
-    const allowed = rightsOf(field);
-    if (allowed === undefined) {
-      bare.push(field.name.value);
-      continue;
-    }
-    for (const held of allowed.filter((one) => !rights.includes(one))) {
-      outside.set(held, [...(outside.get(held) ?? []), field.name.value]);
-    }
-  }
-  if (bare.length > 0) {
-    found.push(`the door ${bare.join(', ')} declares no rights, and every door declares them (VI)`);
-  }
-  for (const [right, ceiling] of ceilingsIn(document)) {
-    if (STRUCTURAL.includes(right)) {
-      found.push(
-        `${right} carries an @invites ceiling, and a structural right is never invited into (VI)`,
-      );
-    } else if (!whole(ceiling.count) || !whole(ceiling.within)) {
-      found.push(
-        `${right}'s @invites ceiling is not two whole numbers of zero or more (VI): count ${ceiling.count}, within ${ceiling.within}`,
-      );
-    }
-  }
-  for (const [held, doors] of outside) {
-    found.push(
-      `the Rights enum does not name ${held}, which ${doors.length} door${doors.length === 1 ? '' : 's'} stand behind: ${doors.join(', ')} (VI)`,
-    );
-  }
-  return found;
-};
-
-const composition = (baseSource, addedSource) => {
-  const refused = (reason) => ({ refused: reason });
-  try {
-    const base = evaluated(baseSource);
-    const added = evaluated(addedSource);
-    if (added === null || typeof added !== 'object') {
-      return refused('the part settles no blueprint object (VIII)');
-    }
-    const standard = doorsIn(base.interface);
-    const collides = [...new Set(doorsIn(added.interface).filter((one) => standard.includes(one)))];
-    if (collides.length > 0) {
-      return refused(
-        `the part declares the door ${collides.join(', ')}, which the administration already names — a standard door name is reserved on both roots (X)`,
-      );
-    }
-    const kept = Object.keys(base.memory ?? {}).filter(
-      (key) => (added.memory ?? {})[key] !== undefined,
-    );
-    if (kept.length > 0) {
-      return refused(
-        `the part declares the cell ${kept.join(', ')}, which the administration already keeps (X)`,
-      );
-    }
-    if (added.needs?.config !== undefined && base.needs?.config !== undefined) {
-      return refused(
-        'the part declares needs.config, and the program it composes with declares one too — a program holds one config (X)',
-      );
-    }
-    const slots = [...(base.needs?.modules ?? []), ...(added.needs?.modules ?? [])];
-    const twice = [
-      ...new Set(
-        slots.map((one) => one.module).filter((name, at, all) => all.indexOf(name) !== at),
-      ),
-    ];
-    if (twice.length > 0) {
-      return refused(
-        `the part declares the module slot ${twice.join(', ')}, which the administration already holds (X)`,
-      );
-    }
-    const cells = { ...(base.memory ?? {}), ...(added.memory ?? {}) };
-    const needs = {
-      ...(base.needs ?? {}),
-      ...(added.needs ?? {}),
-      caller: base.needs?.caller === true || added.needs?.caller === true,
-      modules: slots,
-    };
-    const doors = merged(base.resolvers, added.resolvers);
-    const written = Object.entries(doors)
-      .map(
-        ([type, fields]) =>
-          `${type}: { ${Object.entries(fields)
-            .map(([field, one]) => `${field}: ${one.toString()}`)
-            .join(', ')} }`,
-      )
-      .join(', ');
-    const source = `({
-  name: ${JSON.stringify(added.name)},
-  needs: ${JSON.stringify(needs)},
-  memory: ${JSON.stringify(cells)},
-  interface: ${JSON.stringify(`${base.interface}\n${added.interface}`)},
-  resolvers: { ${written} },
-})`;
-    const found = faults(source);
-    return found.length > 0 ? refused(found.join('; ')) : { source };
-  } catch (error) {
-    return refused(`the part does not compose: ${error.message} (VIII)`);
-  }
-};
-
-const composed = (baseSource, addedSource) => composition(baseSource, addedSource).source;
-
-const inputCheck = (schema, typeName, given) => {
-  const type = schema.getType(typeName);
-  if (type?.getFields === undefined) {
-    return undefined;
-  }
-  let failed = false;
-  const taken = coerceInputValue(given ?? {}, type, () => {
-    failed = true;
-  });
-  return failed || taken === undefined
-    ? undefined
-    : Object.freeze(JSON.parse(JSON.stringify(taken)));
-};
-
-const Blueprint = (source) => {
-  const trespass = reads(source);
-  if (trespass.length > 0) {
-    return { trespass };
-  }
-  try {
-    const written = evaluated(source);
-    const declares = /enum\s+Rights\b/.test(written.interface) ? '' : DEFAULT_RIGHTS;
-    const sdl = [RIGHTS_DIRECTIVE, INVITES_DIRECTIVE, declares, written.interface]
-      .filter(Boolean)
-      .join('\n');
-    const document = parse(sdl);
-    const schema = buildSchema(sdl);
-    const declaredNames = (schema.getType('Rights')?.getValues() ?? []).map((one) => one.name);
-    if (!declares && STRUCTURAL.some((one) => !declaredNames.includes(one))) {
-      return undefined;
-    }
-    const rights = [...new Set([...STRUCTURAL, ...declaredNames])];
-
-    const admits = (typeName, fieldName, held) => {
-      const field = document.definitions
-        .filter((one) => doorHolder(one) && one.name.value === typeName)
-        .flatMap((one) => one.fields ?? [])
-        .find((one) => one.name.value === fieldName);
-      const allowed = field === undefined ? undefined : rightsOf(field);
-      return allowed === undefined ? true : allowed.includes(held);
-    };
-
-    const needs = written.needs ?? {};
-    const modules = needs.modules ?? [];
-    const memory = written.memory ?? {};
-    const misdeclared = Object.entries(memory).filter(
-      ([key, cell]) => !CLASSES.includes(cell?.class) || coreClass(key) !== undefined,
-    );
-    if (misdeclared.length > 0) {
-      return undefined;
-    }
-    const undeclared = rootsIn(document, schema).filter((one) => {
-      const allowed = rightsOf(one);
-      return allowed === undefined || allowed.some((held) => !rights.includes(held));
-    });
-    if (undeclared.length > 0) {
-      return undefined;
-    }
-    const ceilings = ceilingsIn(document);
-    const misinvited = [...ceilings].filter(
-      ([right, ceiling]) =>
-        STRUCTURAL.includes(right) || !whole(ceiling.count) || !whole(ceiling.within),
-    );
-    if (misinvited.length > 0) {
-      return undefined;
-    }
-
-    return Object.freeze({
-      admits,
-      invites: (held) => ceilings.get(held),
-      bindings: (given) =>
-        modules
-          .filter((one) => one.binding !== undefined)
-          .reduce((taken, one) => {
-            if (taken === undefined) {
-              return undefined;
-            }
-            const checked = inputCheck(schema, one.binding, given?.[one.module]);
-            return checked === undefined ? undefined : { ...taken, [one.module]: checked };
-          }, {}),
-      classOf: (key) => coreClass(key) ?? declaredClass(memory, key),
-      declares: (key) => declaredClass(memory, key),
-      config: (given) =>
-        needs.config === undefined ? Object.freeze({}) : inputCheck(schema, needs.config, given),
-      digest: Tools.digest(
-        Tools.canon({
-          interface: sdl,
-          memory,
-          name: written.name,
-          needs,
-          resolvers: resolverSources(written.resolvers ?? {}),
-        }),
-      ),
-      caller: needs.caller === true,
-      memory: Object.freeze(memory),
-      modules,
-      name: written.name,
-      resolvers: written.resolvers ?? {},
-      rights,
-      schema,
-      // The directive definition stays: pointer.mjs runs buildSchema on this output.
-      sdlFor: (held) => {
-        const kept = document.definitions
-          .map((one) =>
-            doorHolder(one)
-              ? {
-                  ...one,
-                  fields: (one.fields ?? []).filter((field) => {
-                    const allowed = rightsOf(field);
-                    return allowed === undefined || allowed.includes(held);
-                  }),
-                }
-              : one,
-          )
-          .filter((one) => !doorHolder(one) || one.fields.length > 0);
-        const defined = new Set(
-          kept
-            .filter((one) => one.kind === Kind.OBJECT_TYPE_DEFINITION)
-            .map((one) => one.name.value),
-        );
-        // A filtered view where only a part's extension survives must still
-        // stand alone as a schema, or the right it serves opens nothing.
-        return print({
-          ...document,
-          definitions: kept.map((one) =>
-            one.kind === Kind.OBJECT_TYPE_EXTENSION && !defined.has(one.name.value)
-              ? { ...one, kind: Kind.OBJECT_TYPE_DEFINITION }
-              : one,
-          ),
-        });
-      },
-      trespass: [],
-    });
-  } catch {
-    return undefined;
-  }
-};
-
-export {
-  Blueprint,
-  CLASSES,
-  CORE_ONLY,
-  FORBIDDEN,
-  OPEN,
-  STRUCTURAL,
-  composed,
-  composition,
-  coreClass,
-  faults,
-  reads,
-};

package/client.mjs

@@ -1,70 +0,0 @@
-import { Stamp, Tools } from './tools.mjs';
-
-const speaking = (born, at, succession) => {
-  if (succession === undefined) {
-    return born;
-  }
-  if (!Array.isArray(succession)) {
-    return undefined;
-  }
-  let pk = born;
-  for (const step of succession) {
-    const next = typeof step?.next === 'string' ? Tools.pkOf(step.next) : null;
-    if (next === null) {
-      return undefined;
-    }
-    if (!Tools.verifies(pk, Tools.canon({ at, next: step.next, v: step.v }), step.sig)) {
-      return undefined;
-    }
-    pk = next;
-  }
-  return pk;
-};
-
-const Client = ({ voice, deliver, resolve = (one) => one }) => {
-  const stamp = Stamp();
-  const lanes = new Map();
-  const send = async (to, op) => {
-    const at = resolve(to);
-    const born = at === undefined ? null : Tools.pkOf(at);
-    if (born === null) {
-      return undefined;
-    }
-    const turn = (lanes.get(at) ?? Promise.resolve()).then(async () => {
-      const envelope = await Tools.envelope(voice, at, 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);
-      const answering = speaking(born, at, reply?.succession);
-      return reply?.body === undefined ||
-        answering === undefined ||
-        !Tools.verifies(answering, Tools.canon({ body: reply.body, claim }), reply.sig)
-        ? undefined
-        : reply;
-    });
-    const settled = turn.then(
-      () => undefined,
-      () => undefined,
-    );
-    lanes.set(at, settled);
-    settled.then(() => {
-      if (lanes.get(at) === settled) {
-        lanes.delete(at);
-      }
-    });
-    return turn;
-  };
-
-  return Object.freeze({
-    address: Tools.address(voice.pk),
-    ask: (to, source, variables) => send(to, { ask: { source, variables } }),
-    describe: (to) => send(to, { describe: {} }),
-    introspect: (to) => send(to, { introspect: {} }),
-    pk: voice.pk,
-    release: (to) => send(to, { release: {} }),
-    send,
-  });
-};
-
-export { Client, speaking };

package/contract.mjs

@@ -1,98 +0,0 @@
-import { buildSchema, isEnumType, isInputObjectType, specifiedScalarTypes } from 'graphql';
-import { Tools } from './tools.mjs';
-
-const argsAgree = (wanted, given) => {
-  for (const arg of wanted.args ?? []) {
-    const same = (given.args ?? []).find((one) => one.name === arg.name);
-    if (same === undefined || String(same.type) !== String(arg.type)) {
-      return false;
-    }
-  }
-  return (given.args ?? [])
-    .filter((one) => !(wanted.args ?? []).some((asked) => asked.name === one.name))
-    .every((one) => !String(one.type).endsWith('!') || one.defaultValue !== undefined);
-};
-
-const Contract = (name, sdl) => {
-  try {
-    const schema = buildSchema(sdl);
-    return Object.freeze({
-      digest: Tools.digest(Tools.canon({ interface: sdl, name })),
-      name,
-      satisfies: (offered) => {
-        const theirs = (() => {
-          try {
-            return buildSchema(offered);
-          } catch {
-            return undefined;
-          }
-        })();
-        if (theirs === undefined) {
-          return false;
-        }
-        for (const [typeName, wanted] of Object.entries(schema.getTypeMap())) {
-          if (typeName.startsWith('__')) {
-            continue;
-          }
-          const given = theirs.getTypeMap()[typeName];
-          if (given === undefined && !specifiedScalarTypes.some((one) => one.name === typeName)) {
-            return false;
-          }
-          if (isEnumType(wanted)) {
-            if (
-              !isEnumType(given) ||
-              !wanted.getValues().every((one) => given.getValue(one.name) !== undefined)
-            ) {
-              return false;
-            }
-            continue;
-          }
-          if (wanted.getFields === undefined) {
-            continue;
-          }
-          if (given?.getFields === undefined) {
-            return false;
-          }
-          for (const [field, held] of Object.entries(wanted.getFields())) {
-            const mine = given.getFields()[field];
-            if (mine === undefined || String(mine.type) !== String(held.type)) {
-              return false;
-            }
-            if (!argsAgree(held, mine)) {
-              return false;
-            }
-          }
-          if (isInputObjectType(wanted)) {
-            const demanded = Object.entries(given.getFields())
-              .filter(([field]) => wanted.getFields()[field] === undefined)
-              .filter(
-                ([, one]) => String(one.type).endsWith('!') && one.defaultValue === undefined,
-              );
-            if (demanded.length > 0) {
-              return false;
-            }
-          }
-        }
-        return true;
-      },
-      sdl,
-    });
-  } catch {
-    return undefined;
-  }
-};
-
-const Contracts = (written) => {
-  const held = Object.entries(written).map(([name, sdl]) => Contract(name, sdl));
-  if (held.some((one) => one === undefined)) {
-    return undefined;
-  }
-  const byName = new Map(held.map((one) => [one.name, one]));
-  return Object.freeze({
-    digests: () => Object.fromEntries(held.map((one) => [one.name, one.digest])),
-    get: (name) => byName.get(name),
-    has: (name) => byName.has(name),
-  });
-};
-
-export { Contract, Contracts };