nervur 0.14.0 → 0.16.0

package/GETTING-STARTED.md

@@ -1,111 +0,0 @@
-# Getting started — two castles
-
-Picture a castle: one gate, its own residents, its own law. A **ground** is
-the castle — one sovereign process, one handler where every letter arrives.
-Its residents are **beings**; its capabilities are **modules**; the ground
-under it is a **floor** — a filesystem, or a browser's IndexedDB — and the
-stance it takes toward the world is its **terrain**. This page raises two
-castles on two terrains and has them speak: a **mountain** (a server, always
-reachable, always remembering) and a **house of cards** (a browser tab,
-raised in seconds, holding what it can afford to lose). Same castle, same
-law, different ground under it.
-
-Everything below runs today — the bench drives this exact story in
-`bench/worlds/story/`.
-
-## The mountain
-
-The machine's raise is one config and one daemon —
-[`nervurd`](https://www.npmjs.com/package/nervurd) is the host, and its
-README is the operator's full page. The five-minute shape:
-
-```sh
-npm install -g nervurd
-nervur self mint --self ./hand.json --heir ./heir.json
-nervur init --config ./castle.json --self ./hand.json
-NERVUR_SECRET=... nervurd --config ./castle.json
-```
-
-The config names the shelf, the door, the secret's environment variable,
-and the modules — the castle's capabilities, chosen by you:
-
-```json
-{
-  "cells": "/var/lib/nervur/castle.json",
-  "listen": { "host": "127.0.0.1", "port": 7001 },
-  "secret": "NERVUR_SECRET",
-  "modules": {}
-}
-```
-
-Keep the heir off the machine. Whoever takes the machine takes what the
-castle holds today; the heir is why they can never become it tomorrow.
-
-## The house of cards
-
-The browser's raise is two calls from
-[`@nervur-org/floor-web`](https://www.npmjs.com/package/@nervur-org/floor-web),
-because a tab closes constantly and the two acts must not blur:
-
-```js
-import { found, wake } from '@nervur-org/floor-web';
-
-// Once, ever: mint the identity, stand the castle, get custody back.
-let kept;
-const castle = found({ keep: (dump) => (kept = dump) });
-// castle.address — the name; castle.custody — the hand, the heir, the
-// secret: yours to keep (IndexedDB, or a mountain you trust), never the
-// ground's.
-
-// Every session after: same name, same residents, no identity act.
-// wake hands back the standing ground itself — woken.address is the name.
-const woken = wake({ held: kept, secret: castle.custody.secret });
-```
-
-Where `kept` and `custody` live is your choice, under this terrain's honest
-limit: a browser may evict what it keeps — a card castle holds what it can
-afford to lose, and keeps what is precious in its relationship with a
-mountain.
-
-## They speak
-
-A letter is a letter on every terrain: one signed envelope, carried
-however the two castles can reach each other — here, `fetch` to the
-mountain's door. First the mountain's keeper invites the card castle's
-founder (one signed act at the admin door — the CLI, or any client the
-keeper holds), and then the founder asks from the browser:
-
-```js
-import { Client, Tools, Voice } from 'nervur';
-
-const me = Voice.revive(castle.custody.hand);
-const talk = Client({
-  voice: me,
-  deliver: async (envelope) => {
-    const res = await fetch('http://127.0.0.1:7001', {
-      body: JSON.stringify(envelope),
-      headers: { 'content-type': 'application/json' },
-      method: 'POST',
-    });
-    return res.status === 200 ? res.json() : undefined;
-  },
-});
-
-const heard = await talk.ask(mountainAddress, '{ census { active } }');
-```
-
-The client verifies every answer from the address alone — the mountain's
-word arrives signed, and a broken or missing signature is dropped exactly
-like silence. A stranger who was never invited gets silence too, and cannot
-tell refusal from absence. That is the whole protocol: **say who you are,
-name whom you seek, and the castle answers or keeps quiet.**
-
-## Where to go next
-
-- [`nervur`'s README](README.md) — the library underneath both castles.
-- [`nervurd`'s README](../nervurd/README.md) — the operator's page: checks,
-  rotation, backups, the door's full behaviour.
-- [`@nervur-org/floor-web`](../floor-web/README.md) — the web floor's
-  terrain contract, founding and waking in full.
-- [`@nervur-org/species`](../species/README.md) — blueprints your castles
-  grow beings from.

package/SECURITY.md

@@ -1,11 +0,0 @@
-# Security
-
-This package answers one question — by whose authority — and a hole in that
-answer is the most serious bug it can have.
-
-Report vulnerabilities privately to **<security@nervur.com>**. Do not open a
-public report. State what you ran, what you sent, and what answered; a
-proof of concept is welcome but not required.
-
-A person reads every report. Fixes ship as releases on the live 0.x line,
-and the report is credited if you want it to be.

package/admin.mjs

@@ -1,83 +0,0 @@
-const ADMIN = `({
-  name: 'nervur.ground',
-  needs: { modules: [{ module: 'memory', contract: 'nervur.memory' }] },
-  memory: {
-    'aliases/*': { type: 'String', class: 'data' },
-    wears: { type: 'String', class: 'data' },
-  },
-  interface: \`
-    input RefInput { address: String!, nextPkHash: String, rights: String }
-    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])
-      attest(module: String!): Boolean @rights(is: [SELF, MEMBER])
-      opened: Boolean                  @rights(is: [SELF, MEMBER, STRANGER])
-      wears: String                    @rights(is: [SELF, MEMBER, STRANGER])
-    }
-    type Mutation {
-      invite(address: String!, nextPkHash: String, rights: String): Boolean @rights(is: [SELF, MEMBER])
-      drop(address: String!): Boolean                       @rights(is: [SELF, MEMBER])
-      extend(program: String): Boolean                      @rights(is: [SELF])
-      create(program: String!, refs: [RefInput!], data: String, config: String): String
-        @rights(is: [SELF, MEMBER])
-      activate(address: String!): String                   @rights(is: [SELF, MEMBER])
-      destroy(address: String!): String                    @rights(is: [SELF, MEMBER])
-      upgrade(address: String!, program: String!): Boolean  @rights(is: [SELF, MEMBER])
-      alias(name: String!, address: String!): Boolean       @rights(is: [SELF, MEMBER])
-      wear(address: String): Boolean                        @rights(is: [SELF, MEMBER])
-    }
-  \`,
-  resolvers: {
-    Query: {
-      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,
-      wears: (_, __, { modules }) => modules.memory.read('wears') ?? null,
-    },
-    Mutation: {
-      invite: (_, { address, nextPkHash, rights }, { modules }) =>
-        modules.memory.write('refs/' + address, {
-          nextPkHash: nextPkHash ?? null,
-          rights: rights ?? 'MEMBER',
-        }) !== undefined,
-      drop: (_, { address }, { modules }) => {
-        if (modules.memory.read('refs/' + address) === undefined) {
-          return false;
-        }
-        modules.memory.write('refs/' + address, undefined);
-        return modules.memory.read('refs/' + address) === undefined;
-      },
-      extend: (_, { program }, { registry }) => registry.extend(program) !== undefined,
-      create: (_, { program, refs, data, config }, { registry }) =>
-        registry.create({
-          config: config === undefined ? undefined : JSON.parse(config),
-          data: data ? JSON.parse(data) : {},
-          program,
-          refs: refs ?? [],
-        }),
-      activate: (_, { address }, { registry }) =>
-        registry.activate(address) === undefined ? null : address,
-      destroy: (_, { address }, { registry }) => registry.destroy(address) ?? null,
-      upgrade: (_, { address, program }, { registry }) =>
-        registry.upgrade({ address, program }) !== undefined,
-      alias: (_, { name, address }, { modules }) =>
-        modules.memory.write('aliases/' + name, address) !== undefined,
-      wear: (_, { address }, { modules }) => {
-        modules.memory.write('wears', address ?? undefined);
-        return modules.memory.read('wears') === (address ?? undefined);
-      },
-    },
-  },
-})`;
-
-export { ADMIN };