@nervur-org/dock 0.4.1 → 0.6.0

package/human/worlds.ts

@@ -11,7 +11,7 @@
 // `tab.ts` is the shell over this, and this is what the memory harbor proves.
 import type { Harbor, Hosted } from 'nervur/harbor';
 import { Avatar, USER } from '../beings/avatar.ts';
-import { settled } from '../dock/faculty.ts';
+import { settled } from '../box/join.ts';
 
 // Which worlds a device has joined, and where each one lives. A tab learns
 // this from the page it is on, one world per origin, and needs it only to
@@ -113,14 +113,14 @@ export async function fresh(ward: Hosted): Promise<Relation> {
   // is a tab that hangs.
   for (let n = 1; n <= 64; n++) {
     const key = `r${n}`;
-    const out = (await ward.ask('boot', { key, class: 'Presence' })) as { error?: string };
+    const out = (await ward.ask('boot', { key, class: 'beings/Presence' })) as { error?: string };
     if (out.error) continue;
     // She takes what the box lends at her birth, and birth is synchronous
     // while taking a standing is not. She is handed back when they have
     // landed, not before: a screen painted from her describe a moment early
     // is a page missing every faculty of the box, and nothing paints it
     // again until the person navigates.
-    await settled();
+    await settled(ward);
     return { key, avatar: ward.being(key) as Avatar };
   }
   throw new Error('the tab could not boot an avatar: every key it tries is taken');

package/mcp/agent.ts

@@ -21,7 +21,7 @@ export type Run = (event: JsonObject) => Promise<Json>;
 
 // The ask on the user being that takes the result. Gated to devices; the
 // agent's client identity is what the gate reads.
-export const REPORT = 'report';
+const REPORT = 'report';
 
 // `claude -p` or any CLI agent: the command runs in the agent's folder with
 // the event, as JSON, as its last argument. The result is what it printed.

package/mcp/allow.ts

@@ -92,7 +92,8 @@ export class Exchange {
       const world = worlds.find((w) => w.pk === inv.ward);
       if (!world) return again('That invitation is for a world that does not live here.');
       const identity = word(f.get('identity'));
-      if (identity === null || identity === world.user || identity === 'desk') return again('An identity is one word, and not the user or the desk.');
+      // the ward judges the rest: an identity that is one of its beings is refused at the join
+      if (identity === null) return again('An identity is one word.');
       const joined = await this.o.join(identity, inv, world.ward);
       if (joined.error) return again(`Not in: ${joined.error}.`);
       const out = await this.o.oauth.complete(request, identity, world.ward);

package/mcp/http.ts

@@ -14,7 +14,7 @@ import type { Serving } from '../beings/side.ts';
 import { mcpSide } from './server.ts';
 
 export type Session = { identity: string; ward: string; transport: StreamableHTTPServerTransport; serving: Serving; touched: number };
-export const SESSION_IDLE = 60 * 60 * 1000;
+const SESSION_IDLE =60 * 60 * 1000;
 // An identity in a world: one harbor holds many, and the grant names which.
 export type Resolve = (identity: string, ward: string) => Promise<{ avatar?: Avatar; error?: string }>;
 

package/mcp/oauth.ts

@@ -5,7 +5,7 @@
 // S256, the code grant, refresh, opaque tokens. It is a route, not Quo. Its
 // one job is to end with a client identity, which the front desk trades for
 // an invitation and the avatar knocks with; the grant it issues is the
-// box's, `dock/grants.ts`, honoured on every route, and what this file
+// box's, `box/grants.ts`, honoured on every route, and what this file
 // keeps for itself is only the dance: clients, pending requests and codes.
 // No secret of Quo's is ever here.
 //
@@ -18,9 +18,9 @@
 // The web route finishes a request by calling `complete(request, identity)`
 // after its allow page, where the human hands the invitation the root minted;
 // that returns the redirect that carries the code back to the client.
-import { REFRESH_TTL, type Grants } from '../dock/grants.ts';
+import { REFRESH_TTL, type Bearers as Grants } from '../box/grants.ts';
 
-export { ACCESS_TTL, REFRESH_TTL } from '../dock/grants.ts';
+export { ACCESS_TTL, REFRESH_TTL } from '../box/grants.ts';
 
 // A code, a client id: every key here is a string the far side chose, and a
 // bare lookup would find `__proto__` and hand back an object with no
@@ -244,7 +244,7 @@ function withQuery(base: string, params: Record<string, string | null>): string
   return u.toString();
 }
 
-export async function readBody(req: Request, limit = 64 * 1024): Promise<string> {
+async function readBody(req: Request, limit = 64 * 1024): Promise<string> {
   const s = await req.text();
   if (s.length > limit) throw new Error('too large');
   return s;

package/mcp/route.ts

@@ -9,7 +9,7 @@
 import { OAuth, type Store } from './oauth.ts';
 import type { McpHttp } from './http.ts';
 import type { Handler } from '../harbor/http.ts';
-import type { Grants } from '../dock/grants.ts';
+import type { Bearers as Grants } from '../box/grants.ts';
 
 // The routes' public faces, as the exchange and the metadata name them.
 export type Routes = { mcp: string; web: string; quo?: string; api?: string };

package/mcp/runner.ts

@@ -19,7 +19,7 @@ import { presentation } from '../beings/look.ts';
 // from the device and never from cells. `turns` is the ceiling of model
 // calls in one turn of the conversation; ten by default.
 export type Model = { url: string; model: string; key?: string; turns?: number };
-export const TURNS = 10;
+const TURNS = 10;
 
 // The wire shapes, only as much as the loop reads and writes.
 export type Tool = { type: 'function'; function: { name: string; description?: string; parameters: JsonObject } };

package/mcp/server.ts

@@ -22,7 +22,7 @@ export const VERSION = '0.0.0';
 export type { Subject } from '../beings/side.ts';
 
 // The empty ask as a tool: her describe whole, asks and notes.
-export const DESCRIBE: Tool = { name: 'describe', description: 'the empty ask: her describe, the asks and the notes', inputSchema: { type: 'object' } };
+const DESCRIBE: Tool ={ name: 'describe', description: 'the empty ask: her describe, the asks and the notes', inputSchema: { type: 'object' } };
 
 // Her describe, spoken as tools, the empty ask first. Name, description and
 // input are verbatim; an output schema crosses when she declared one. Her

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nervur-org/dock",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "The dock: what every estate on Quo needs and nobody writes twice. A daemon and the nervur command, the front desk, the user being and the avatar, harbors on disk, in a tab and on the edge, the model sides and the screen.",
   "keywords": [
     "quo",
@@ -28,7 +28,6 @@
       "types": "./dist/harbor/disk.d.ts",
       "default": "./dist/harbor/disk.js"
     },
-    "./cli": "./dist/cli/nervur.js",
     "./stand": {
       "types": "./dist/cli/stand.d.ts",
       "default": "./dist/cli/stand.js"
@@ -79,10 +78,11 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && node build/bundle.ts && chmod +x dist/cli/nervur.js && cp harbor/edge/platform.d.ts dist/harbor/edge/ && cp -R cli/estate dist/cli/ && cp ../../papers/quo-dock.md ../../papers/quo-app-bells.md ../../papers/quo-human.md ../../papers/quo-mcp.md ../../papers/quo-api.md ../../papers/quo-harbor.md ../../papers/GLOSSARY.md ../../papers/WORLDS.md ../../papers/GETTING_STARTED.md .",
-    "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:dock' >&2; exit 1; }"
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node build/bundle.ts && chmod +x dist/cli/nervur.js && cp harbor/edge/platform.d.ts dist/harbor/edge/ && cp -R cli/estate dist/cli/",
+    "check": "node ../../test.mjs \"test/*.test.ts\"",
+    "deep": "node --test --test-timeout=900000 --test-concurrency=1 \"test/terrain/*.test.ts\"",
+    "cover": "node --test --test-timeout=300000 --test-concurrency=1 --experimental-test-coverage --test-coverage-exclude=\"**/dist/**\" --test-coverage-exclude=\"**/test/**\" --test-coverage-exclude=\"**/harbor/idb.ts\" --test-coverage-lines=97 --test-coverage-branches=85 --test-coverage-functions=91 \"test/*.test.ts\"",
+    "prepublishOnly": "test \"$NERVUR_GATED\" = 1 || { echo 'a publish is /release, from the root, on the human'\"'\"'s word' >&2; exit 1; }"
   },
   "dependencies": {
     "@aparajita/capacitor-secure-storage": "^8.0.0",
@@ -91,9 +91,10 @@
     "@capacitor/filesystem": "^8.1.3",
     "@capacitor/geolocation": "^8.2.2",
     "@capacitor/local-notifications": "^8.3.1",
+    "@capacitor/push-notifications": "^8.1.2",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "nervur": "^0.17.0",
-    "@nervur-org/ui": "^0.3.0",
+    "nervur": "^0.19.0",
+    "@nervur-org/ui": "^0.5.0",
     "ws": "^8.21.3"
   },
   "devDependencies": {
@@ -107,21 +108,12 @@
   "files": [
     "dist",
     "beings",
-    "dock",
+    "box",
     "cli",
     "harbor",
     "mcp",
     "human",
     "api",
-    "quo-dock.md",
-    "quo-app-bells.md",
-    "quo-human.md",
-    "quo-mcp.md",
-    "quo-api.md",
-    "quo-harbor.md",
-    "GLOSSARY.md",
-    "WORLDS.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 ana --domain acme.com --default --show
-npx nervur serve --dir ~/.nervur --http 8787
-```
-
-`init` mints the ward `acme`, boots ana'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":"ana","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`.

package/GLOSSARY.md

@@ -1,118 +0,0 @@
-# GLOSSARY
-
-Every word the papers above the spec use, in one place. The protocol's own
-words, being, ward, harbor, standing, occupant, invitation, knock and the
-rest, are in the glossary of `quo/SPEC.md`, which assumes nothing and
-is not repeated here; what the library spells for itself is in
-`papers/quo-kit.md`. A word here is a convention of the dock or of an
-estate, and changes no word of the spec. `papers/WORLDS.md` is where the
-first seven are reasoned; `papers/quo-dock.md` and the papers of its sides
-are where the rest are built.
-
-## A person and a world
-
-- **org**: the unit every "you" names: a company, a family, a club, a
-  service, and at the smallest one human alone, an org of one. An org owns
-  wards, holds standings, trusts boxes and is trusted. Never an avatar, an
-  account or a user id; each of those is a thing an org holds.
-- **world**: a ward, as a human sees it: one seed, one partition, one body
-  of code, one owner.
-- **home**: the one ward an org owns on a harbor it trusts; the org's own
-  being is its being. Also that being's standing at the ward's own door as
-  an owner, `home`. One per org, and an org may have none yet.
-- **org being**: home's own being, one per org, running day and night,
-  holding the org's standings and its members as occupants. An estate's
-  own class for an organisation; the user being for an org of one.
-- **presence**: a ward a person owns on a harbor in her hand, one per world
-  reached from that device. The tab, the phone and the desk are presences
-  of the same shape, and nothing in a hand is a home.
-- **presence being**: the being of a world who lives on a device, booted in
-  the presence ward when the world is joined. She lends every faculty the
-  box has at her birth and carries them, so a world reaches the device only
-  by asking her.
-- **app**: a browser of worlds, one harbor and a presence ward per world,
-  the same shell on every terrain. It has no account and no person of its
-  own; which app a person uses is settled at home, and an adopter's app is
-  only the first one its member meets.
-- **membership**: an id in a ward someone else owns. An employee id, a
-  member id, a customer id. Never a ward of hers.
-- **hub**: home, as the one place every relation of hers meets.
-- **rule**: home answering one standing by asking another.
-- **device**: a harbor in her hand, with a ward of its own holding what that
-  box can do. One OS user is one harbor, and the app has no people of its
-  own.
-
-## The dock
-
-- **dock**: what every estate needs and nobody writes twice,
-  `packages/dock/`, published as `@nervur-org/dock`.
-- **dock ward**: the ward a harbor boots and roots for itself, holding the
-  faculties that box lends. Never a home, and never migrated.
-- **estate**: all of one owner's harbors, with what is theirs alone, in a
-  tree of the owner's own and never published.
-- **daemon**: `nervur serve`, the one process on a device that holds a harbor.
-- **route**: a hostname a reverse proxy sends to one process: `web.`,
-  `quo.`, `mcp.`, `api.`.
-- **user being**: the org being of an org of one: a human's own, holding
-  all of her standings. The dock's `User` class, which also serves a
-  membership the desk makes in another org's ward.
-- **front desk**: the being every fresh client meets; hands out invitations
-  minted by the ward's being, and is what `nervur init` marks public in a
-  fresh ward. Any ward may mark one being of any class public instead.
-- **avatar**: a being that is someone's voice from outside Quo, one per
-  client identity.
-- **side**: the interface an avatar speaks through to someone outside Quo:
-  a screen, an MCP server, a runner, an agent.
-- **client identity**: what a credential exchange establishes; one avatar,
-  for life.
-- **proof**: a vouch the front desk trades once for an invitation: the
-  daemon's nonce for a local side, or the link a world mailed to an address
-  it wants proof of. Everyone else arrives with an invitation.
-- **way in**: a being who says who a proof of one kind is for, and who sends
-  the proof out to an address where the kind has one. The desk holds a
-  standing at each, under `way:<kind>`: the box's, lent by the dock ward,
-  and the world's own, in the world's ward.
-- **carrier**: a being who shows her standings' asks as her own and
-  forwards. The user being and the device are two.
-- **envoy**: a being of the org's standing in for a ward nobody here runs,
-  one being per vendor and one relation per account, on the base
-  `beings/envoy.ts`. Her asks out are the vendor's surface, narrowed; her
-  one ask in, `deliver`, is the owner's, the vendor's bytes reaching her
-  own body through the api route and never a door; her credential is in
-  her cells, placed by the owner and shown to nobody; and a delivery is one
-  ask on the way back her occupant handed her at the knock.
-- **faculty**: a being of the dock ward, standing for one thing the box can
-  do: a timer, a line, a store, a vendor's API. Reached by `lend`, held as
-  an ordinary standing, and she wakes whoever invited her. She holds what
-  the device holds and begins holding it at birth.
-- **ring**: one platform's way of waking a device by its token, held by the
-  push faculty: `web`, `apns`, `fcm`. It carries the banner sealed to that
-  device's banner key, and nothing else.
-- **bell**: a ward that wakes devices, with a public being for a phone
-  nobody knows and one doorbell per device. `papers/quo-app-bells.md`.
-- **doorbell**: one device's being at a bell. Its cells hold that device's
-  platform token, and its occupants are the worlds that device allowed to
-  wake it, one standing each.
-- **porter**: a bell's public being, where a phone nobody knows arrives as
-  `{}` and comes away with a doorbell of its own.
-- **banner key**: the pair a device keeps in the cells of its notifications
-  faculty. A world seals a notification to its public half; the secret half
-  opens banners and nothing else, and never the world.
-- **timer**: the faculty that reads the box's clock, and the only thing on a
-  device that may. She wakes whoever invited her, every minute.
-- **clock**: the being who wakes beings at a time, on standings the root
-  placed. She holds the schedules and invited the timer.
-- **gate**: `for(occupant, asker)`; the whole permission model.
-- **look**: how a being is presented, as values; one optional ask.
-- **page**: a being's page as a tree of values in the screen's grammar; one
-  optional ask, read by a screen alone.
-- **owner pilot**: `nervur pilot`, the model side over a ward's owner asks,
-  reaching the daemon's socket; with `--via`, a ward elsewhere through a
-  standing. Under cron, the estate's own agent.
-
-## The model side
-
-- **constitution**: the folder and instructions an autonomous agent runs
-  under; governance, never permission.
-- **runner**: an inline MCP client for a model that speaks function
-  calling; it drives the loop the MCP client would, over one conversation.