nervur 0.17.0 → 0.18.0

package/README.md

@@ -17,13 +17,16 @@ Nothing else is Quo.
   beings and judges its door.
 - **Being.** One ordinary object, one voice.
 
-[`protocol/SPEC.md`](protocol/SPEC.md) is the truth. It is the protocol
-alone: what any ward in any language must do for its bytes to be Quo. It is
+The truth is the spec, at <https://quo.systems/spec>, with the vectors it
+is proved by at <https://quo.systems/vectors>. It is the protocol alone:
+what any ward in any language must do for its bytes to be Quo. It is
 self-contained and assumes nothing from any other document, this README
-included. Read it first.
-[`quo-kit.md`](quo-kit.md) is this kit: what one TypeScript
-implementation chose and another kit may refuse. It assumes the spec, and
-where the two disagree the spec wins.
+included. Read it first, at the source, which is Quo's and not this
+package's to carry.
+
+What this one kit chose, and another kit may refuse, is documented at
+<https://nervur.org/docs>. It assumes the spec, and where the two disagree
+the spec wins.
 
 ## This package
 
@@ -33,8 +36,6 @@ source it was emitted from, because Node strips types nowhere under
 `node_modules`.
 
 ```
-protocol/         the shelf a kit in any language reads: SPEC.md and the vectors, no code
-protocol/vectors/ fixed inputs and outputs, so another language proves its bytes
 src/being/        the Being side: what a being author imports, if anything
 src/ward/         the ward: the Ground contract, door, seal, arithmetic, heirs, stance, allowance
 src/harbor/       MemoryHarbor, and the harbor core with its store, reach and dialer
@@ -74,32 +75,30 @@ import { Stand } from 'nervur/vector';
 
 ## Another language
 
-The hand to a kit in another language is one folder, `protocol/`, and it
-holds two things of two kinds. `SPEC.md` is the protocol, and it assumes
-nothing: a kit is written against it and against nothing else here. The
-vectors beside it are the byte-level hand, everything a stranger can
-observe: `protocol/vectors/arithmetic.json`, the primitives the seal rests
-on, SHA-256, Ed25519, X25519, HKDF and AES-256-GCM;
-`protocol/vectors/framing.json`, Quo's own, the ward pk, the digest, the
-signed ask body, the sealed shapes, the invitation and the knock;
-`protocol/vectors/wire.json`, the frames on a socket and the one request a
-door takes; and `protocol/vectors/door.json`, the door's thirteen cases,
-each one an arrival a ward will not answer, with the bytes that arrive, the
-bytes that leave and the partition's digest on both sides of the judgement.
-They import by name,
-`nervur/protocol/vectors/framing.json`, so a kit's own suite can
-read them from the package. A kit reproduces them or it is not this
-protocol. `door.json` is also replayed from outside, by a verifier holding
-no key, against a kit standing in vector mode, which `SPEC.md` describes
-under that name. This kit stands in it with `Stand` from `nervur/vector`,
-which is vector mode and names no runtime: put it behind any listener that
-hands it a request body and returns what it answers.
-
-Nothing outside that folder is the protocol. `src/` is this kit's
+The hand to a kit in another language is Quo's own and not this package's.
+The spec is the protocol and assumes nothing: a kit is written against it
+and against nothing else. The vectors beside it are the byte-level hand,
+everything a stranger can observe: `arithmetic.json`, the primitives the
+seal rests on, SHA-256, Ed25519, X25519, HKDF and AES-256-GCM;
+`framing.json`, Quo's own, the ward pk, the digest, the signed ask body,
+the sealed shapes, the invitation and the knock; `wire.json`, the frames on
+a socket and the one request a door takes; and `door.json`, the door's
+thirteen cases, each one an arrival a ward will not answer, with the bytes
+that arrive, the bytes that leave and the partition's digest on both sides
+of the judgement. All of it is at <https://quo.systems>, downloadable and
+versionless, and a kit reproduces the bytes or it is not this protocol.
+
+`door.json` is also replayed from outside, by a verifier holding no key,
+against a kit standing in vector mode, which the spec describes under that
+name. This kit stands in it with `Stand` from `nervur/vector`, which is
+vector mode and names no runtime: put it behind any listener that hands it
+a request body and returns what it answers.
+
+Nothing in this package is the protocol. `src/` is this kit's
 interpretation, and `src/conformance/` is a checklist a kit ports rather
 than a harness it runs: it imports the base class, the silence spelling and
 this kit's store and reach, so the beings it is shown with run only in a
-TypeScript ward. `quo-kit.md` "The three shelves" says which is which.
+TypeScript ward.
 
 ## Versions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor, with the spec inside.",
   "keywords": [
     "quo",
@@ -39,11 +39,10 @@
       "types": "./dist/vector/index.d.ts",
       "default": "./dist/vector/index.js"
     },
-    "./protocol/*": "./protocol/*",
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "rm -rf dist protocol && tsc -p tsconfig.build.json && mkdir -p protocol && cp ../../quo/SPEC.md protocol/SPEC.md && cp -R ../../quo/vectors protocol/vectors && cp ../../papers/quo-kit.md quo-kit.md && cp ../../papers/GETTING_STARTED.md GETTING_STARTED.md",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "check": "node --test \"test/*.test.ts\"",
     "deep": "node --test \"test/terrain/*.test.ts\"",
     "prepublishOnly": "test \"$NERVUR_GATED\" = 1 || { echo 'publish from the root, gated once: npm run release:nervur' >&2; exit 1; }"
@@ -54,9 +53,6 @@
   "files": [
     "dist",
     "src",
-    "protocol",
-    "quo-kit.md",
-    "GETTING_STARTED.md",
     "README.md",
     "LICENSE",
     "NOTICE"

package/GETTING_STARTED.md

@@ -1,138 +0,0 @@
-# Getting started
-
-Quo lets an object ask another object and get an answer, without knowing
-whether that other object is in the same process, on the same device, or
-on another planet. Three words: a harbor boots wards, a ward keeps beings
-and judges its door, and a being is one ordinary object with one voice.
-This is the shortest road from nothing to each of the three, for a
-stranger with a terminal. `SPEC.md` is the truth behind every sentence
-here and assumes nothing; `quo-dock.md` is the dock, the part a box runs.
-
-Quo is the protocol and Nervur is this kit of it. Every name you install
-and every command you type is Nervur's; `quo` stays on the wire, as the
-`quo.` route a ward's door answers at.
-
-Two packages, and you start with the one that fits what you have:
-
-- `nervur`, the library. A harbor, a ward and a being in one
-  process, no wire, no files. For a program that wants Quo inside it.
-- `@nervur-org/dock`, the dock. A daemon and one command, `nervur`, that
-  stand a box up: a person's world with a page, a model's side, an api, a
-  door on the wire. For a box that receives people and models.
-
-The command is in the dock and not in the library, so `npm install nervur`
-gives you something to import and no command, and the command arrives with
-`npm install -g @nervur-org/dock`. That is how a kit of this shape is
-always named: one unscoped headline name for the library, the parts under
-the scope, and the CLI in the package that owns it.
-
-## A being, in one process
-
-```bash
-npm install nervur
-```
-
-A being is a class with `asks`, the methods anyone may reach, each with
-the JSON schema of its input. Everything else on the class is hers alone.
-
-```js
-import { Being } from 'nervur';
-import { Ward } from 'nervur/ward';
-import { MemoryHarbor } from 'nervur/harbor';
-
-class Shop extends Being {
-  static asks = { price: { input: { type: 'object', properties: { item: { type: 'string' } } } } };
-  price({ item }) {
-    return { item, eur: 12 };
-  }
-}
-class Customer extends Being {
-  static asks = {};
-}
-
-const harbor = new MemoryHarbor();
-const ward = await harbor.boot('acme', Ward, { Shop, Customer });
-await ward.ask('boot', { key: 'shop', class: 'Shop' });
-await ward.ask('boot', { key: 'ana', class: 'Customer' });
-```
-
-The harbor booted a ward named `acme` with two classes it may make beings
-of, and the ward's owner, the process itself, booted one of each by key.
-The ward's own asks are seven, `boot`, `public`, `invite`, `knock`,
-`remove`, `unboot` and `ask`, and `ward.ask()` with no method is her
-describe: those asks and her `notes`, the ward's `pk` and her beings.
-
-Nobody reaches a being she has not invited. An invitation is minted on a
-being for one id, the shop's for `ana`, and the customer knocks with it;
-from then she holds a standing at the shop, under the name she took, and
-the shop holds her as an occupant.
-
-```js
-const invitation = await ward.ask('invite', { being: 'shop', id: 'ana' });
-const ana = harbor.objects.get(harbor.partitions.get('acme').beings.ana);
-await ana.knock(invitation);
-await ana.take('shop', invitation);
-console.log(await ana.standings.shop.ask('price', { item: 'bread' }));
-// { item: 'bread', eur: 12 }
-```
-
-That is the whole protocol: a standing on one side, an occupant on the
-other, an ask that rides the relation and an answer that rides it back.
-The two beings here share a process; the same lines hold when the shop is
-on a box across the sea, because a standing is an address and a key, and
-the harbor owns the wire. `harbor.objects` is the memory harbor's hand for
-a test and a first program; a being on a real box is reached through her
-ward, never held.
-
-## A box
-
-```bash
-npm install @nervur-org/dock
-npx nervur init --dir ~/.nervur --ward acme --user razvan --domain acme.com --default --show
-npx nervur serve --dir ~/.nervur --http 8787
-```
-
-`init` mints the ward `acme`, boots razvan's user being, her doorbell and
-the desk in it, marks it the default ward and shows it at the web route,
-and writes `routes.json`, the four routes of a box, `mcp.`, `web.`, `quo.`
-and `api.` under the domain, for a proxy to map onto the one loopback
-port. Without `--domain`, write it yourself; on a Mac the four are paths
-at one loopback address:
-
-```json
-{ "mcp": "http://127.0.0.1:8787/mcp", "web": "http://127.0.0.1:8787/web", "quo": "http://127.0.0.1:8787/quo", "api": "http://127.0.0.1:8787/api" }
-```
-
-`serve` is the daemon, the one process over that folder, and every other
-command is its client. From a second terminal, a phone:
-
-```bash
-npx nervur invite --dir ~/.nervur '{"being":"razvan","id":"phone"}'
-```
-
-The answer carries `link`, the ward's page with the invitation in its
-fragment. Opened on the phone, the tab boots a harbor of its own, joins as
-that device, and is in: no account, nothing typed. What a model gets is
-the same world as tools at `mcp.`, what a program gets is the same asks as
-JSON at `api.`, and what another box gets is the door at `quo.`; a being
-answers each the same, because each is an ask at her door.
-
-The box's own doings are rows on the faculties of its dock ward, placed by
-the root with `nervur ask --ward dock`: a socket held to another box, an
-agent run for a ward, a schedule on the clock. A second box owns this one
-across the wire with an invitation on the ward's own pk, knocked with
-from there, and every owner command with `--via` from then on. Each of
-those, the edge, and what an estate stands beyond the init, is the
-"Getting started" chapter of `quo-dock.md`, proven cold on a Mac by
-somebody with nothing else to read.
-
-## Your own beings on a box
-
-A box holds the dock's classes and yours. `classes/index.ts` beside the
-wards exports each of yours by name, and `nervur boot '{"key":"shop",
-"class":"Shop"}'` boots one; `nervur init --class Shop` makes the ward's home
-being one of yours, an organisation's ward with the org as its being. A
-being's asks may name who may reach them, `for`, over the record of the
-occupant asking, and her `cells` are what she keeps between boots: the
-whole of what a being is, in `SPEC.md`, and the words above the spec, a
-world, a home, a membership, in `WORLDS.md` and `GLOSSARY.md`.