nervur 0.12.0 → 0.14.0

package/blueprint.mjs

@@ -85,6 +85,8 @@ const doorHolder = (one) =>
 
 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) => {
@@ -150,6 +152,30 @@ const rightsOf = (field) => {
     : 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()
@@ -202,7 +228,9 @@ const faults = (source) => {
     return ['it settles no blueprint object (VIII)'];
   }
   const declares = /enum\s+Rights\b/.test(written.interface) ? '' : DEFAULT_RIGHTS;
-  const sdl = [RIGHTS_DIRECTIVE, declares, written.interface].filter(Boolean).join('\n');
+  const sdl = [RIGHTS_DIRECTIVE, INVITES_DIRECTIVE, declares, written.interface]
+    .filter(Boolean)
+    .join('\n');
   let document;
   let schema;
   try {
@@ -211,13 +239,14 @@ const faults = (source) => {
   } catch (error) {
     return [`its schema does not compile: ${error.message} (VIII)`];
   }
-  const rights = [
-    ...new Set([
-      ...STRUCTURAL,
-      ...(schema.getType('Rights')?.getValues() ?? []).map((one) => one.name),
-    ]),
-  ];
+  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)`);
@@ -240,6 +269,17 @@ const faults = (source) => {
   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)`,
@@ -341,15 +381,16 @@ const Blueprint = (source) => {
   try {
     const written = evaluated(source);
     const declares = /enum\s+Rights\b/.test(written.interface) ? '' : DEFAULT_RIGHTS;
-    const sdl = [RIGHTS_DIRECTIVE, declares, written.interface].filter(Boolean).join('\n');
+    const sdl = [RIGHTS_DIRECTIVE, INVITES_DIRECTIVE, declares, written.interface]
+      .filter(Boolean)
+      .join('\n');
     const document = parse(sdl);
     const schema = buildSchema(sdl);
-    const rights = [
-      ...new Set([
-        ...STRUCTURAL,
-        ...(schema.getType('Rights')?.getValues() ?? []).map((one) => one.name),
-      ]),
-    ];
+    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
@@ -376,9 +417,18 @@ const Blueprint = (source) => {
     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)
@@ -395,7 +445,7 @@ const Blueprint = (source) => {
         needs.config === undefined ? Object.freeze({}) : inputCheck(schema, needs.config, given),
       digest: Tools.digest(
         Tools.canon({
-          interface: print(document),
+          interface: sdl,
           memory,
           name: written.name,
           needs,

package/client.mjs

@@ -1,7 +1,5 @@
 import { Stamp, Tools } from './tools.mjs';
 
-const KEY = /^[0-9a-f]{64}$/;
-
 const speaking = (born, at, succession) => {
   if (succession === undefined) {
     return born;
@@ -11,13 +9,14 @@ const speaking = (born, at, succession) => {
   }
   let pk = born;
   for (const step of succession) {
-    if (!KEY.test(step?.next ?? '')) {
+    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 = Buffer.from(step.next, 'hex');
+    pk = next;
   }
   return pk;
 };
@@ -32,11 +31,15 @@ const Client = ({ voice, deliver, resolve = (one) => one }) => {
       return undefined;
     }
     const turn = (lanes.get(at) ?? Promise.resolve()).then(async () => {
-      const reply = await deliver(Tools.envelope(voice, at, op, stamp()));
+      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(reply.body), reply.sig)
+        !Tools.verifies(answering, Tools.canon({ body: reply.body, claim }), reply.sig)
         ? undefined
         : reply;
     });

package/contract.mjs

@@ -1,4 +1,4 @@
-import { buildSchema, isEnumType, isInputObjectType, parse, print } from 'graphql';
+import { buildSchema, isEnumType, isInputObjectType, specifiedScalarTypes } from 'graphql';
 import { Tools } from './tools.mjs';
 
 const argsAgree = (wanted, given) => {
@@ -16,9 +16,8 @@ const argsAgree = (wanted, given) => {
 const Contract = (name, sdl) => {
   try {
     const schema = buildSchema(sdl);
-    const printed = print(parse(sdl));
     return Object.freeze({
-      digest: Tools.digest(Tools.canon({ interface: printed, name })),
+      digest: Tools.digest(Tools.canon({ interface: sdl, name })),
       name,
       satisfies: (offered) => {
         const theirs = (() => {
@@ -36,6 +35,9 @@ const Contract = (name, sdl) => {
             continue;
           }
           const given = theirs.getTypeMap()[typeName];
+          if (given === undefined && !specifiedScalarTypes.some((one) => one.name === typeName)) {
+            return false;
+          }
           if (isEnumType(wanted)) {
             if (
               !isEnumType(given) ||
@@ -73,7 +75,7 @@ const Contract = (name, sdl) => {
         }
         return true;
       },
-      sdl: printed,
+      sdl,
     });
   } catch {
     return undefined;

package/ground.mjs

@@ -1,17 +1,36 @@
 import { ADMIN } from './admin.mjs';
-import { Being, Compartment, Registry, SUCCESSION, make, rootFor, spend } from './being.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, Paths, Wire } from './modules.mjs';
+import { Memory } from './modules.mjs';
 import { Mcp, Pointer } from './pointer.mjs';
 import { Program } from './program.mjs';
-import { Stamp, Tools } from './tools.mjs';
+import { Bytes, Stamp, Tools } from './tools.mjs';
 import { Voice } from './voice.mjs';
 
 const GROUND = 'Ground';
 
-const FLOOR = ['blueprints', 'cells', 'contracts', 'keychain', 'paths', 'watch', 'wire'];
+const FLOOR = [
+  'blueprints',
+  'cells',
+  'cipher',
+  'contracts',
+  'keychain',
+  'moved',
+  'paths',
+  'watch',
+  'wire',
+];
 
 const UNPROVEN = 'ground/unproven/';
 
@@ -19,7 +38,11 @@ const HEIR = 'ground/heir';
 
 const commits = (cells, bundle) => {
   const boxPk = bundle?.heirBoxPk;
-  if (typeof boxPk !== 'string' || Buffer.from(boxPk, 'base64').length !== 32) {
+  try {
+    if (typeof boxPk !== 'string' || Bytes.unbase64(boxPk).length !== 32) {
+      return undefined;
+    }
+  } catch {
     return undefined;
   }
   cells.put(HEIR, { boxPk, nextPkHash: bundle.nextPkHash });
@@ -43,8 +66,8 @@ const unprovenAt = (cells) => (at) => {
 
 const unprovenRows = (cells) => cells.keys(UNPROVEN).map((row) => cells.peek(row));
 
-const install = ({ cells, keychain, program, bundle }) => {
-  if (bundle?.next !== undefined) {
+const install = ({ cells, keychain, program, bundle, cipher }) => {
+  if (cells.peek('ground/admin') !== undefined || bundle?.next !== undefined) {
     return undefined;
   }
   const voice = Voice.revive(bundle ?? {});
@@ -57,13 +80,13 @@ const install = ({ cells, keychain, program, bundle }) => {
   if (sealed === undefined) {
     return undefined;
   }
-  make({ memory, voice, address, program });
+  make({ memory, voice, address, program, cipher });
   cells.put('ground/admin', { address, sealed });
   commits(cells, bundle);
   return address;
 };
 
-const succeeds = ({ adminMine, adminVoice, address, bundle, cells, keychain, memory }) => {
+const succeeds = ({ adminMine, adminVoice, address, bundle, cells, cipher, keychain, memory }) => {
   if (bundle?.next !== undefined) {
     return undefined;
   }
@@ -72,21 +95,22 @@ const succeeds = ({ adminMine, adminVoice, address, bundle, cells, keychain, mem
   if (heir === undefined || committed?.value !== Tools.digest(heir.pk)) {
     return undefined;
   }
-  const root = rootFor({ memory, voice: adminVoice, address });
+  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: Buffer.from(heir.boxPk).toString('base64'),
-    wrapped: Voice.sealTo(heir.boxPk, root.toString('base64')),
+    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 handover = { at: address, next: Buffer.from(heir.pk).toString('hex'), v: version };
-  const certified = adminMine.write(`${SUCCESSION}${version}`, {
+  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)),
   });
@@ -96,7 +120,7 @@ const succeeds = ({ adminMine, adminVoice, address, bundle, cells, keychain, mem
   const claim = {
     address,
     nextPkHash: heir.nextPkHash,
-    pk: Buffer.from(heir.pk).toString('hex'),
+    pk: Bytes.hex(heir.pk),
     version,
   };
   if (memory.replace({ ...claim, sig: heir.sign(Tools.canon(claim)) }) === undefined) {
@@ -112,7 +136,14 @@ const succeeds = ({ adminMine, adminVoice, address, bundle, cells, keychain, mem
 const Ground = (modules = {}, { span } = {}) => {
   const cells = modules.cells;
   const keychain = modules.keychain;
-  if (cells === undefined || keychain?.seal === undefined || keychain?.unseal === undefined) {
+  const cipher = modules.cipher;
+  if (
+    cells === undefined ||
+    keychain?.seal === undefined ||
+    keychain?.unseal === undefined ||
+    cipher?.seal === undefined ||
+    cipher?.unseal === undefined
+  ) {
     return undefined;
   }
 
@@ -134,7 +165,7 @@ const Ground = (modules = {}, { span } = {}) => {
   const installed = cells.peek('ground/admin');
   if (installed === undefined) {
     return Object.freeze({
-      init: (bundle) => install({ cells, keychain, program, bundle }),
+      init: (bundle) => install({ cells, keychain, program, bundle, cipher: modules.cipher }),
     });
   }
   const bundle = keychain.unseal(installed.sealed);
@@ -155,17 +186,22 @@ const Ground = (modules = {}, { span } = {}) => {
   };
 
   const address = installed.address;
-  const memory = Memory(cells, unprovenAt(cells));
-  const paths = modules.paths ?? Paths(new Map());
-  const wire = modules.wire ?? Wire();
+  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, (source, variables) =>
-          deliver(Tools.envelope(voice, one.at, { ask: { source, variables } }, stamp())),
+        Pointer(written.get(one.contract).sdl, async (source, variables) =>
+          deliver(await Tools.envelope(voice, one.at, { ask: { source, variables } }, stamp())),
         ),
       ]),
     );
@@ -199,9 +235,10 @@ const Ground = (modules = {}, { span } = {}) => {
     memory,
     voice: adminVoice,
     address,
-    root: rootFor({ 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) => {
@@ -223,6 +260,7 @@ const Ground = (modules = {}, { span } = {}) => {
     paths.publish(at, undefined);
     if (voice === undefined) {
       cells.drop(`${at}/`);
+      modules.moved?.(at);
       return undefined;
     }
     return spend({ memory, voice, address: at });
@@ -236,16 +274,31 @@ const Ground = (modules = {}, { span } = {}) => {
     if (one.at === undefined) {
       return null;
     }
-    const seen = await deliver(Tools.envelope(adminVoice, one.at, { describe: {} }, stamp()));
+    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,
@@ -255,18 +308,16 @@ const Ground = (modules = {}, { span } = {}) => {
     vouched,
     attest,
     watch,
+    extended: () => {
+      adminDoor = undefined;
+    },
   });
-  const admin = (envelope, token) =>
-    Being({
-      address,
-      deliver: (envelope) => deliver(envelope),
-      modules: modulesFor(adminVoice, adminDeclared()),
-      registry,
-      span,
-      vouched,
-      voice: adminVoice,
-      watch,
-    })(envelope, token);
+  const admin = (envelope, token) => {
+    if (adminDoor === undefined) {
+      adminDoor = buildAdmin();
+    }
+    return adminDoor(envelope, token);
+  };
 
   announce(address);
   for (const key of adminMine.list('identity/custody/')) {
@@ -284,7 +335,16 @@ const Ground = (modules = {}, { span } = {}) => {
     address,
     receive,
     rotate: (bundle) =>
-      succeeds({ adminMine, adminVoice, address, bundle, cells, keychain, memory }),
+      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;

package/index.mjs

@@ -13,8 +13,8 @@ export {
 export { Client, speaking } from './client.mjs';
 export { Contract, Contracts } from './contract.mjs';
 export { FLOOR, GROUND, Ground } from './ground.mjs';
-export { Cells, Clock, Dns, Entropy, Keychain, Memory, Paths, Wire } from './modules.mjs';
+export { Memory } from './modules.mjs';
 export { Mcp, Pointer } from './pointer.mjs';
 export { Program } from './program.mjs';
-export { MEASURE, SPAN, Stamp, Tools } from './tools.mjs';
+export { Bytes, MEASURE, SPAN, Stamp, Tools } from './tools.mjs';
 export { Voice } from './voice.mjs';

package/modules.mjs

@@ -1,38 +1,13 @@
-import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { Tools } from './tools.mjs';
+import { Bytes, Tools } from './tools.mjs';
 
-const Cells = ({ file } = {}) => {
-  const cells = new Map(
-    file && existsSync(file) ? Object.entries(JSON.parse(readFileSync(file, 'utf8'))) : [],
-  );
-  const flush = () => {
-    if (file) {
-      writeFileSync(`${file}.next`, JSON.stringify(Object.fromEntries(cells)));
-      renameSync(`${file}.next`, file);
-    }
-  };
-  return Object.freeze({
-    drop: (prefix) => {
-      for (const cell of [...cells.keys()].filter((one) => one.startsWith(prefix))) {
-        cells.delete(cell);
-      }
-      flush();
-    },
-    dump: () => JSON.stringify(Object.fromEntries(cells)),
-    keys: (prefix) => [...cells.keys()].filter((cell) => cell.startsWith(prefix)),
-    peek: (cell) => cells.get(cell),
-    put: (cell, held) => {
-      cells.set(cell, held);
-      flush();
-    },
-  });
-};
-
-const Memory = (cells, unproven) => {
+// 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) : Buffer.from(chain.value, 'hex');
+    return chain === undefined ? Tools.pkOf(address) : Bytes.unhex(chain.value);
   };
   return Object.freeze({
     list: (address, prefix) =>
@@ -42,16 +17,17 @@ const Memory = (cells, unproven) => {
 
     replace: ({ address, pk, nextPkHash, sig }) => {
       const committed = held(address, 'chain/nextPkHash');
-      if (committed === undefined || Tools.digest(Buffer.from(pk, 'hex')) !== committed.value) {
+      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(Buffer.from(pk, 'hex'), Tools.canon(claim), sig)) {
+      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;
     },
 
@@ -68,45 +44,12 @@ const Memory = (cells, unproven) => {
         return undefined;
       }
       cells.put(`${address}/${key}`, { value, version });
+      if (!key.startsWith('refs/')) {
+        moved?.(address);
+      }
       return version;
     },
   });
 };
 
-const Clock = (ticks) => {
-  let at = 0;
-  return Object.freeze({ now: () => ticks[Math.min(at++, ticks.length - 1)] });
-};
-
-const Entropy = (grains) => {
-  let at = 0;
-  return Object.freeze({ grain: () => grains[Math.min(at++, grains.length - 1)] });
-};
-
-const Keychain = (secret) =>
-  Object.freeze({
-    seal: (value) => {
-      try {
-        return Tools.seal(secret, value);
-      } catch {
-        return undefined;
-      }
-    },
-    unseal: (sealed) => Tools.unseal(secret, sealed),
-  });
-
-const Dns = () => new Map();
-
-const Paths = (dns) =>
-  Object.freeze({
-    find: (address) => dns.get(address),
-    publish: (address, endpoint) =>
-      endpoint === undefined ? dns.delete(address) : dns.set(address, endpoint),
-  });
-
-const Wire = () =>
-  Object.freeze({
-    carry: async (endpoint, envelope) => (endpoint === undefined ? undefined : endpoint(envelope)),
-  });
-
-export { Cells, Clock, Dns, Entropy, Keychain, Memory, Paths, Wire };
+export { Memory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "A distributed system of sovereign beings — one door, one question: by whose authority.",
   "license": "Apache-2.0",
   "author": "Razvan Gherghina",
@@ -11,12 +11,15 @@
   },
   "files": [
     "*.mjs",
-    "NOTICE"
+    "GETTING-STARTED.md",
+    "NOTICE",
+    "SECURITY.md"
   ],
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
+    "@noble/curves": "2.3.0",
     "graphql": "^17.0.2"
   }
 }

package/program.mjs

@@ -90,6 +90,7 @@ const Program = (source) => {
     config: blueprint.config,
     declares: blueprint.declares,
     digest: blueprint.digest,
+    invites: blueprint.invites,
     introspect: async (held) => {
       const filtered = seenBy(held);
       if (filtered === undefined) {