nervur 0.7.1 → 0.7.5

package/admin.mjs

@@ -4,7 +4,8 @@ const ADMIN = `({
   memory: { 'aliases/*': { type: 'String', class: 'data' } },
   interface: \`
     input RefInput { address: String!, nextPkHash: String, rights: String }
-    type Census { stored: Int!, active: Int! }
+    type Resident { address: String!, alias: String, digest: String, active: Boolean! }
+    type Census { residents: [Resident!]!, stored: Int!, active: Int! }
     type Query {
       census: Census                   @rights(is: [SELF, MEMBER])
       aliasOf(name: String!): String   @rights(is: [SELF, MEMBER])
@@ -23,10 +24,14 @@ const ADMIN = `({
   \`,
   resolvers: {
     Query: {
-      census: (_, __, { registry }) => ({
-        active: registry.active(),
-        stored: registry.stored(),
-      }),
+      census: (_, __, { registry }) => {
+        const residents = registry.residents();
+        return {
+          active: residents.filter((one) => one.active).length,
+          residents,
+          stored: residents.length,
+        };
+      },
       aliasOf: (_, { name }, { modules }) => modules.memory.read('aliases/' + name),
       attest: (_, { module }, { registry }) => registry.attest(module),
       opened: (_, __, { modules }) => modules.memory.list('refs/').length > 0,

package/being.mjs

@@ -56,13 +56,13 @@ const rootFor = ({ memory, voice, address }) => {
   return opened === undefined ? undefined : Buffer.from(opened, 'base64');
 };
 
-const Port = ({ voice, mine, modules, rights }) => {
+const Port = ({ voice, mine, deliver, rights }) => {
   const stamp = Stamp();
   const lanes = new Map();
   const send = async (to, op) => {
     const turn = (lanes.get(to) ?? Promise.resolve()).then(() => {
       const handle = mine.read(`handles/${to}`);
-      return modules.deliver(
+      return deliver(
         Tools.envelope(handle === undefined ? voice : Voice.revive(handle.face), to, op, stamp()),
       );
     });
@@ -112,7 +112,7 @@ const rotates = ({ mine }, from, nextPkHash) => {
   return from;
 };
 
-const Being = ({ voice, address, modules, registry, vouched, watch }) => {
+const Being = ({ voice, address, deliver, modules, registry, vouched, watch }) => {
   const memory = modules.memory;
   const root = rootFor({ memory, voice, address });
   const source = memory.read(address, 'program')?.value;
@@ -214,7 +214,7 @@ const Being = ({ voice, address, modules, registry, vouched, watch }) => {
         const asked = await program.ask({
           context: {
             modules: Object.freeze({ ...modules, memory: scoped(mine, program) }),
-            port: Port({ voice, mine, modules, rights }),
+            port: Port({ voice, mine, deliver, rights }),
             registry,
             rights,
           },
@@ -257,6 +257,8 @@ const make = ({ memory, voice, address, program }) => {
 const Registry = ({
   memory,
   adminMine,
+  address,
+  deliver,
   modules,
   modulesFor,
   announce,
@@ -266,22 +268,28 @@ const Registry = ({
   watch,
 }) => {
   const live = new Map();
-  const activate = (address) => {
-    if (live.has(address)) {
-      return live.get(address);
+  const activate = (at) => {
+    if (live.has(at)) {
+      return live.get(at);
     }
-    const held = adminMine.read(`identity/custody/${address}`);
+    const held = adminMine.read(`identity/custody/${at}`);
     const voice = held === undefined ? undefined : Voice.revive(held);
     if (voice === undefined) {
       return undefined;
     }
-    const door = Being({ voice, address, modules: modulesFor(voice), vouched, watch });
-    live.set(address, door);
+    const door = Being({
+      address: at,
+      deliver,
+      modules: modulesFor(voice),
+      vouched,
+      voice,
+      watch,
+    });
+    live.set(at, door);
     return door;
   };
   return Object.freeze({
     activate,
-    active: () => live.size,
     attest,
     create: ({ program, refs = [], data = {}, bindings, config } = {}) => {
       const written = program === undefined ? undefined : Program(program);
@@ -329,43 +337,67 @@ const Registry = ({
       announce(address);
       return address;
     },
-    deactivate: (address) => live.delete(address),
-    upgrade: ({ address, program }) => {
-      const held = adminMine.read(`identity/custody/${address}`);
-      const voice = held === undefined ? undefined : Voice.revive(held);
+    deactivate: (at) => live.delete(at),
+    upgrade: ({ address: target, program }) => {
       const written = program === undefined ? undefined : Program(program);
-      if (voice === undefined || written === undefined) {
+      if (written === undefined) {
         return undefined;
       }
       const orphaned = memory
-        .list(address, '')
-        .filter((key) => memory.read(address, key)?.value !== null)
+        .list(target, '')
+        .filter((key) => memory.read(target, key)?.value !== null)
         .filter((key) => written.classOf(key) === undefined);
       if (orphaned.length > 0) {
         return undefined;
       }
+      if (target === address) {
+        return adminMine.write('program', program) === undefined ? undefined : target;
+      }
+      const held = adminMine.read(`identity/custody/${target}`);
+      const voice = held === undefined ? undefined : Voice.revive(held);
+      if (voice === undefined) {
+        return undefined;
+      }
       const claim = {
-        address,
+        address: target,
         key: 'program',
         value: program,
-        version: (memory.read(address, 'program')?.version ?? 0) + 1,
+        version: (memory.read(target, 'program')?.version ?? 0) + 1,
       };
       if (memory.write({ ...claim, sig: voice.sign(Tools.canon(claim)) }) === undefined) {
         return undefined;
       }
-      live.delete(address);
-      return address;
+      live.delete(target);
+      return target;
     },
-    destroy: (address) => {
-      if (adminMine.read(`identity/custody/${address}`) === undefined) {
+    destroy: (at) => {
+      if (adminMine.read(`identity/custody/${at}`) === undefined) {
         return undefined;
       }
-      adminMine.write(`identity/custody/${address}`, undefined);
-      live.delete(address);
-      forget(address);
-      return address;
+      adminMine.write(`identity/custody/${at}`, undefined);
+      live.delete(at);
+      forget(at);
+      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,
+        };
+      });
     },
-    stored: () => adminMine.list('identity/custody/').length,
   });
 };
 

package/ground.mjs

@@ -94,10 +94,7 @@ const Ground = (modules = {}) => {
         {
           ...extra,
           ...boundFor(voice),
-          deliver: (envelope) => deliver(envelope),
           memory,
-          paths,
-          wire,
         },
         Tools.address(voice.pk),
       ),
@@ -147,6 +144,8 @@ const Ground = (modules = {}) => {
   const registry = Registry({
     memory,
     adminMine,
+    address,
+    deliver: (envelope) => deliver(envelope),
     modules: adminModules,
     modulesFor,
     announce,
@@ -155,14 +154,16 @@ const Ground = (modules = {}) => {
     attest,
     watch,
   });
-  const admin = Being({
-    voice: adminVoice,
-    address,
-    modules: adminModules,
-    registry,
-    vouched,
-    watch,
-  });
+  const admin = (envelope, token) =>
+    Being({
+      address,
+      deliver: (envelope) => deliver(envelope),
+      modules: adminModules,
+      registry,
+      vouched,
+      voice: adminVoice,
+      watch,
+    })(envelope, token);
 
   announce(address);
   for (const key of adminMine.list('identity/custody/')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.7.1",
+  "version": "0.7.5",
   "description": "A distributed system of sovereign beings — one door, one question: by whose authority.",
   "license": "Apache-2.0",
   "author": "Razvan Gherghina",