@nervur-org/dock 0.5.0 → 0.6.0

package/dist/beings/carry.js

@@ -1,11 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
-// A carrier: a being who shows the asks of the standings she holds as asks
-// of her own, and forwards. Whoever she carries for sees, in one describe,
+// Carrying: a being shows the asks of the standings she holds as asks of
+// her own, and forwards. Whoever she carries for sees, in one describe,
 // what she can be asked and what every being she holds can be asked, each
 // under that standing's name; asking one is an ask on that standing, in her
 // name, so the far being sees her and never who is behind her. A user being
-// carries acme for the human's devices; a house being could carry its
-// rooms; nothing here knows what she is.
+// carries her org for the human's devices; a presence being carries her
+// device's faculties to her world; the Dock carries the box's faculties to
+// a screen. Nothing here knows what she is.
+//
+// It is composed and never extended: carrying is something a being does,
+// not what she is, so a being on any rung of the kit's ladder carries by
+// answering through `carry` and saying her rules as statics of her class.
+// The four rules have a default each, and a class says only the ones she
+// means to change.
 //
 // A carried ask is `<id>-<name>`, and the mapping back is kept in her cells
 // and never parsed from the name, so an id with a dash in it is no trouble.
@@ -18,8 +25,21 @@
 // `look` once per digest, and keeps both in her cells. So a describe of
 // hers may cost one ask per stale standing, which is the price of a page
 // that is never more than one ask behind.
-import { Being, isSilence, isWord, wordOf } from 'nervur';
+import { isSilence, isWord, wordOf } from 'nervur';
 import { sanitise } from './look.js';
+export const CARRIES = {
+    carries: () => false,
+    hidden: (id) => id.startsWith('to:'),
+    skips: () => false,
+    shows: () => true,
+};
+// Her rules, read off her class; one she left unsaid is the default.
+function rulesOf(self) {
+    const C = self.constructor;
+    return { carries: C.carries ?? CARRIES.carries, hidden: C.hidden ?? CARRIES.hidden, skips: C.skips ?? CARRIES.skips, shows: C.shows ?? CARRIES.shows };
+}
+const carriedOf = (self) => (self.cells.carried ??= {});
+const looksOf = (self) => (self.cells.looks ??= {});
 // The names a far being carries, read off her notes: every ask her
 // `standings` groups name, and each group's page. Empty when she carries
 // nothing, which a bare avatar does not.
@@ -39,136 +59,108 @@ function carriedBy(bp) {
     }
     return out;
 }
-export class Carrier extends Being {
-    // Who sees what she carries. Nobody, until a subclass says who.
-    static carries(_occupant, _asker) {
-        return false;
-    }
-    // Standings that are plumbing: their own asks are never carried, and
-    // what they carry is. A way back to a device is one, by the dock's own
-    // convention, so a bare avatar's inbox never shows on her and a presence
-    // being's faculties do, under `to:<id>-<name>`, which is how home carries
-    // her phone. A subclass may name more.
-    static hidden(id) {
-        return id.startsWith('to:');
-    }
-    // Standings she never reads for carrying at all: a presence being's
-    // standing at her own user being is one, since carrying it would carry
-    // the user being's carrying of her, and round. None, until a subclass
-    // says which.
-    static skips(_id) {
-        return false;
-    }
-    // Which of the standings she carries this asker may see. Every one,
-    // until a subclass keeps some for fewer: a user being shows her own door
-    // to a device that may mint and to nobody else.
-    static shows(_id, _occupant, _asker) {
-        return true;
-    }
-    get carried() {
-        return (this.cells.carried ??= {});
-    }
-    get looks() {
-        return (this.cells.looks ??= {});
-    }
-    // Her describe with her standings carried into it, for an asker who may
-    // see them. Every other asker gets her describe alone.
-    async blueprint(asker) {
-        const C = this.constructor;
-        const bp = this.describe(asker);
-        if (!C.carries(this.occupant(asker), asker))
-            return bp;
-        const own = new Set(bp.asks.map((a) => a.name));
-        const carried = {};
-        const groups = {};
-        const occ = this.occupant(asker);
-        // By id, and never in the order she happened to take them. Her cells keep
-        // standings in the order they were taken, which is the order a lend
-        // answered, a device came back or a relation was dropped and taken again:
-        // history, and no fact about her. Carried into her blueprint in that
-        // order, her shape would come out differently on two runs that made her
-        // the same way, and her digest with it. The digest is how everyone
-        // holding a standing on her learns she changed, so a shape that follows
-        // history says she changed when nothing about her did, and a watcher
-        // refreshes or walks away over the order two lends came back in.
-        for (const [id, rec] of [...Object.entries(this.cells.standings)].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
-            if (C.skips(id))
-                continue;
-            const st = this.standings[id];
-            if (!st)
+// Her describe with her standings carried into it, for an asker who may
+// see them. Every other asker gets her describe alone.
+export async function blueprint(self, asker) {
+    const rules = rulesOf(self);
+    const bp = self.describe(asker);
+    const occ = self.occupant(asker);
+    if (!rules.carries(occ, asker))
+        return bp;
+    const own = new Set(bp.asks.map((a) => a.name));
+    const carried = {};
+    const groups = {};
+    const looks = looksOf(self);
+    // By id, and never in the order she happened to take them. Her cells keep
+    // standings in the order they were taken, which is the order a lend
+    // answered, a device came back or a relation was dropped and taken again:
+    // history, and no fact about her. Carried into her blueprint in that
+    // order, her shape would come out differently on two runs that made her
+    // the same way, and her digest with it. The digest is how everyone
+    // holding a standing on her learns she changed, so a shape that follows
+    // history says she changed when nothing about her did, and a watcher
+    // refreshes or walks away over the order two lends came back in.
+    for (const [id, rec] of [...Object.entries(self.cells.standings)].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+        if (rules.skips(id))
+            continue;
+        const st = self.standings[id];
+        if (!st)
+            continue;
+        if (!rec.blueprint || rec.seen !== rec.digest)
+            await st.ask(); // her ward writes the record
+        if (!rec.blueprint)
+            continue;
+        // plumbing carries what it carries and nothing of its own: the names
+        // the far being's notes group under her standings, or none
+        const through = rules.hidden(id) ? carriedBy(rec.blueprint) : null;
+        if (through && through.size === 0)
+            continue;
+        // The mapping is written for every standing she carries, whoever is
+        // asking: it is one map in her cells, and the last describe must not
+        // decide what the next asker may call. Who sees a standing is decided
+        // here and again at answer, by `shows`.
+        const shown = rules.shows(id, occ, asker);
+        // her look is kept here once per digest and never carried as an ask;
+        // her page follows every call, so it is carried as one and named in
+        // the notes, where every side finds it and none takes it for a form
+        const names = [];
+        const group = { asks: names };
+        for (const a of rec.blueprint.asks) {
+            if (a.name === 'look')
                 continue;
-            if (!rec.blueprint || rec.seen !== rec.digest)
-                await st.ask(); // her ward writes the record
-            if (!rec.blueprint)
+            if (through && !through.has(a.name))
                 continue;
-            // plumbing carries what it carries and nothing of its own: the names
-            // the far being's notes group under her standings, or none
-            const through = C.hidden(id) ? carriedBy(rec.blueprint) : null;
-            if (through && through.size === 0)
+            const name = `${id}-${a.name}`;
+            if (own.has(name))
                 continue;
-            // The mapping is written for every standing she carries, whoever is
-            // asking: it is one map in her cells, and the last describe must not
-            // decide what the next asker may call. Who sees a standing is decided
-            // here and again at answer, by `shows`.
-            const shown = C.shows(id, occ, asker);
-            // her look is kept here once per digest and never carried as an ask;
-            // her page follows every call, so it is carried as one and named in
-            // the notes, where every side finds it and none takes it for a form
-            const names = [];
-            const group = { asks: names };
-            for (const a of rec.blueprint.asks) {
-                if (a.name === 'look')
-                    continue;
-                if (through && !through.has(a.name))
-                    continue;
-                const name = `${id}-${a.name}`;
-                if (own.has(name))
-                    continue;
-                carried[name] = { id, ask: a.name };
-                if (!shown)
-                    continue;
-                bp.asks.push({ ...a, name });
-                if (a.name === 'page')
-                    group.page = name;
-                else
-                    names.push(name);
-            }
+            carried[name] = { id, ask: a.name };
             if (!shown)
                 continue;
-            if (rec.blueprint.asks.some((a) => a.name === 'look')) {
-                const kept = this.looks[id];
-                if (!kept || kept.digest !== rec.digest) {
-                    const l = await st.ask('look');
-                    this.looks[id] = { digest: rec.digest, look: isSilence(l) || isWord(l) ? {} : sanitise(l) };
-                }
-                group.look = this.looks[id].look;
+            bp.asks.push({ ...a, name });
+            if (a.name === 'page')
+                group.page = name;
+            else
+                names.push(name);
+        }
+        if (!shown)
+            continue;
+        if (rec.blueprint.asks.some((a) => a.name === 'look')) {
+            const kept = looks[id];
+            if (!kept || kept.digest !== rec.digest) {
+                const l = await st.ask('look');
+                looks[id] = { digest: rec.digest, look: isSilence(l) || isWord(l) ? {} : sanitise(l) };
             }
-            groups[id] = group;
+            group.look = looks[id].look;
         }
-        for (const id of Object.keys(this.looks))
-            if (!(id in groups))
-                delete this.looks[id];
-        this.cells.carried = carried;
-        const notes = bp.notes !== null && typeof bp.notes === 'object' && !Array.isArray(bp.notes) ? bp.notes : {};
-        return { asks: bp.asks, notes: { ...notes, standings: groups } };
+        groups[id] = group;
     }
-    async answer(asker, method, args = {}) {
-        if (method === undefined)
-            return this.blueprint(asker);
-        const C = this.constructor;
-        const to = Object.hasOwn(this.carried, method) ? this.carried[method] : undefined;
-        const occ = this.occupant(asker);
-        if (to && C.carries(occ, asker) && C.shows(to.id, occ, asker)) {
-            const st = this.standings[to.id];
-            if (!st)
-                return { error: 'unknown ask' };
-            const out = await st.ask(to.ask, args);
-            if (isSilence(out))
-                return out;
-            if (isWord(out))
-                return { error: wordOf(out) };
+    for (const id of Object.keys(looks))
+        if (!(id in groups))
+            delete looks[id];
+    self.cells.carried = carried;
+    const notes = bp.notes !== null && typeof bp.notes === 'object' && !Array.isArray(bp.notes) ? bp.notes : {};
+    return { asks: bp.asks, notes: { ...notes, standings: groups } };
+}
+// Her answer, carrying: the empty ask is her carried blueprint, a carried
+// name is an ask on that standing in her name, and everything else is her
+// own, which the class hands in as `own`.
+export async function carry(self, asker, method, args, own) {
+    if (method === undefined)
+        return blueprint(self, asker);
+    const rules = rulesOf(self);
+    const carried = carriedOf(self);
+    const to = Object.hasOwn(carried, method) ? carried[method] : undefined;
+    const occ = self.occupant(asker);
+    if (to && rules.carries(occ, asker) && rules.shows(to.id, occ, asker)) {
+        const st = self.standings[to.id];
+        if (!st)
+            return { error: 'unknown ask' };
+        const out = await st.ask(to.ask, args);
+        if (isSilence(out))
             return out;
-        }
-        return super.answer(asker, method, args);
+        if (isWord(out))
+            return { error: wordOf(out) };
+        return out;
     }
+    return own(asker, method, args);
 }

package/dist/beings/clock.js

@@ -30,7 +30,10 @@
 // from a file and nothing is set on the class, so a schedule outlives the
 // process the way every cell does, and is gone when it is dropped.
 import { Being, isSilence, isWord, wordOf, OWNER } from 'nervur';
-import { TIMER, join } from '../dock/index.js';
+import { TIMER as TIMING } from '../box/timer.js';
+import { join } from '../box/join.js';
+// Her standing at the box's timer, under an id of her own.
+const TIMER = 'timer';
 // The root and nobody else. `OWNER` is one of the ward's own words, refused at
 // every mint, so no occupant can ever wear it: an ask gated this way is the
 // device's own and cannot be reached through a door.
@@ -286,7 +289,7 @@ export class Clock extends Being {
     joined;
     constructor(stance) {
         super(stance);
-        this.joined = join(this, TIMER, { method: 'tick' });
+        this.joined = join(this, TIMING, TIMER, { method: 'tick' });
     }
     static asks = {
         tick: { description: 'fire everything due at this moment, and answer the tally and when she is next due', input: NOW, for: timer },
@@ -351,9 +354,9 @@ export class Clock extends Being {
     async told() {
         if (!Object.hasOwn(this.cells.standings, TIMER))
             return;
-        const timer = this.standings[TIMER];
-        const said = await timer?.ask('now', {});
-        const now = said !== null && typeof said === 'object' ? said.now : undefined;
+        const hers = this.standings[TIMER];
+        const heard = await hers?.ask('now', {});
+        const now = heard !== null && typeof heard === 'object' ? heard.now : undefined;
         if (typeof now !== 'number' || !Number.isFinite(now))
             return;
         // A schedule due at this very moment is a round now, not a round at the
@@ -361,7 +364,7 @@ export class Clock extends Being {
         // and the schedule kept inside it names it.
         const at = this.schedules().some((s) => this.#ready(s, now)) ? now : this.#soonest(floor(now));
         if (at !== null)
-            await timer?.ask('due', { at });
+            await hers?.ask('due', { at });
     }
     // One list, her own cell and nothing else.
     schedules() {
@@ -509,7 +512,7 @@ export const CLOCK = 'clock';
 // because it is the same act: the owner creates and places, and the work is
 // hers from then on.
 export async function setupClock(hosted, wakes = []) {
-    const out = (await hosted.ask('boot', { key: CLOCK, class: 'Clock' }));
+    const out = (await hosted.ask('boot', { key: CLOCK, class: 'beings/Clock' }));
     if (out.error)
         throw new Error(`clock: ${out.error}`);
     for (const being of wakes)

package/dist/beings/desk.js

@@ -8,7 +8,7 @@
 // way in turns a proof of one kind into who it is for: which user, which
 // client identity. The ways in are beings, and the desk reaches each of
 // them as she reaches anything, at a standing under `way:<kind>`: the
-// world's own, placed by the root, and the box's, lent by the dock ward and
+// world's own, placed by the root, and the box's, lent by the box ward and
 // taken at her birth, so a box with no local side offers no such kind.
 //
 // A kind whose proof the world has to hand out first answers `send` beside
@@ -17,8 +17,8 @@
 // sent to before, or what a link says. She keeps the ways in named in one
 // place, so a side that renders her renders every way into this world.
 import { Being, isSilence, isWord, wordOf } from 'nervur';
-import { join } from '../dock/faculty.js';
-import { LOCAL } from '../dock/local.js';
+import { join } from '../box/join.js';
+import { LOCAL } from '../box/local.js';
 import { WAY, kindOf, verified } from './way.js';
 export class Desk extends Being {
     static asks = {
@@ -31,7 +31,7 @@ export class Desk extends Being {
     // nothing under that id and the kind is not offered.
     constructor(stance) {
         super(stance);
-        void join(this, LOCAL, undefined, WAY(LOCAL));
+        void join(this, LOCAL, WAY('local'));
     }
     // The ids of the ways in she holds, in the order they were placed.
     get ways() {
@@ -116,9 +116,10 @@ export class Desk extends Being {
         // key. A way in that does not say `make` reaches an existing household
         // and nothing else, which is what the local kind on a device does.
         if (!this.standings[id] && (who.make === true || typeof who.make === 'string')) {
-            if (!/^[\w.-]{1,80}$/.test(who.user) || who.user === 'desk')
-                return { error: 'a user is a word, and not desk' };
-            if ((await this.boot(typeof who.make === 'string' ? who.make : 'User', who.user, id)) === null)
+            // a key the ward already holds, her own included, is refused by the boot
+            if (!/^[\w.-]{1,80}$/.test(who.user))
+                return { error: 'a user is a word' };
+            if ((await this.boot(typeof who.make === 'string' ? who.make : 'beings/User', who.user, id)) === null)
                 return { error: 'no such user' };
             await this.standings[id].ask('hello', { name: who.user });
         }

package/dist/beings/doorbell.d.ts

@@ -4,6 +4,7 @@ declare const isDevice: (occ: OccupantRecord | undefined) => boolean;
 declare const isWorld: (occ: OccupantRecord | undefined) => boolean;
 declare const isMaker: (occ: OccupantRecord | undefined) => occ is OccupantRecord;
 export declare class Doorbell extends Being {
+    static readonly at = "beings/Doorbell";
     static cells: JsonObject;
     static asks: {
         claim: {
@@ -69,7 +70,8 @@ export declare class Doorbell extends Being {
     };
     describe(asker: Parameters<Being['describe']>[0]): import("nervur").Blueprint;
     claim(_args: JsonObject, asker: Asker): Promise<JsonObject>;
-    keep(args: JsonObject): JsonObject;
+    keep(args: JsonObject): Promise<JsonObject>;
+    private at;
     admit(_args: JsonObject): Promise<JsonObject>;
     drop(args: JsonObject): JsonObject;
     allowed(_args: JsonObject): JsonObject;

package/dist/beings/doorbell.js

@@ -28,11 +28,17 @@ const DEVICE = 'device';
 const MINE = 'push';
 // What a platform will carry. It is the faculty's number, because the
 // faculty is the one that hands a ring to a platform.
-import { SEAL } from '../dock/push.js';
+import { SEAL, isToken } from '../box/ring.js';
+import { PUSH } from '../box/push.js';
+import { join } from '../box/join.js';
 const isDevice = (occ) => occ?.id === DEVICE;
 const isWorld = (occ) => occ !== undefined && occ.id !== DEVICE;
 const isMaker = (occ) => occ !== undefined;
 export class Doorbell extends Being {
+    // Where this class lives in a tree, which is her key in a ward. She says
+    // it herself, so the porter who boots her spells no path of her own and a
+    // class moved is one line moved with it.
+    static at = 'beings/Doorbell';
     static cells = { token: null, admitted: 0, claimed: false };
     static asks = {
         claim: { description: 'the one way in for this doorbell, handed out once', input: { type: 'object' }, for: isMaker },
@@ -70,13 +76,40 @@ export class Doorbell extends Being {
     }
     // Written once and rewritten whenever the platform hands the phone a new
     // one. No world is told anything, because no world was ever given it.
-    keep(args) {
+    //
+    // A kind is one of the rings the box behind this bell holds, and a token
+    // of any other kind is refused here, at the door, with an error object.
+    // The faculty is asked which kinds it rings, because the faculty is the
+    // one that hands a ring to a platform and nothing else on this bell knows.
+    // A device told at the moment it hands a token can hand another or ask its
+    // human for a bell that can reach it; a device told nothing goes on
+    // believing it is reachable until a world rings and is refused, and by then
+    // the only one who could act is the only one not there.
+    async keep(args) {
         const token = args.token;
-        if (token === null || typeof token !== 'object' || Array.isArray(token) || typeof token.kind !== 'string')
+        if (!isToken(token))
             return { error: 'a token names its kind' };
+        const at = await this.at();
+        if (!at)
+            return { error: 'this box rings nothing' };
+        const said = await at.ask('kinds', {});
+        if (said === undefined || isSilence(said))
+            return { error: 'this box rings nothing' };
+        if (isWord(said))
+            return { error: wordOf(said) };
+        const kinds = said.kinds;
+        if (!Array.isArray(kinds))
+            return { error: 'this box rings nothing' };
+        if (!kinds.includes(token.kind))
+            return { error: `this box cannot ring a ${token.kind}` };
         this.cells.token = token;
         return { kept: token.kind };
     }
+    // Her standing at the box's push faculty, taken the first time it is
+    // wanted and held from then on.
+    async at() {
+        return this.standings[MINE] ?? (await join(this, PUSH, MINE).then(() => this.standings[MINE]));
+    }
     // The device allows a world by asking for a way in and handing it over.
     // So a world can only ring a phone that chose it.
     async admit(_args) {
@@ -113,7 +146,7 @@ export class Doorbell extends Being {
         const token = this.cells.token;
         if (token === null)
             return { error: 'this device has handed no token' };
-        const at = this.standings[MINE] ?? (await this.lend(MINE, MINE).then(() => this.standings[MINE]));
+        const at = await this.at();
         if (!at)
             return { error: 'this box rings nothing' };
         const out = await at.ask('ring', { token, sealed });

package/dist/beings/index.d.ts

@@ -2,13 +2,33 @@ export { User, DESK, HOME, BELL } from './user.ts';
 export { Desk } from './desk.ts';
 export { WAY, kindOf, verified, VERIFY, SEND, type Proof, type Verified } from './way.ts';
 export { Avatar, USER, PUSHER } from './avatar.ts';
-export { Carrier } from './carry.ts';
+export { carry, blueprint, CARRIES, type Carrying } from './carry.ts';
 export { Presence } from './presence.ts';
 export { Courier, MOVER, isMoving, type Moving } from './courier.ts';
 export { Porter } from './porter.ts';
 export { Doorbell } from './doorbell.ts';
-export { Envoy, owner, occupant, type Delivery, type Wake, type Heard } from './envoy.ts';
-export { DOCK, CONSOLE, LOCAL, LOCATION, NOTIFICATIONS, PUSH, TIMER, FACULTIES, FACULTY_CLASSES, Console, Faculty, Local, Location, Notifications, Push, Timer, isToken, join, settled, stand, standOn, lending, facultyOf, type Ring, type Token, type Where, type Watched, type Woke, type Rooted } from '../dock/index.ts';
-export { webPush, mintVapid, publicOf, apnsPush, pkcs8, HOSTS, fcmPush, isAccount, DOORS, handedTo, ringing, routed, type Vapid, type Apns, type Account, type Doors } from '../dock/index.ts';
+export { BOX, BOX_SEED, Dock, LOCAL, LOCATION, NOTIFICATIONS, PUSH, TIMER, Faculty, Local, Location, Notifications, Push, Timer, contract, covers, nameOf, titleOf, keyed, join, settled, stand, standHarbor, classes, lent, type Contract, type Tree, type Where, type Watched, type Rooted } from '../box/index.ts';
+export { isToken, type Ring, type Token } from '../box/index.ts';
+export { webPush, mintVapid, publicOf, apnsPush, pkcs8, HOSTS, fcmPush, isAccount, DOORS, handedTo, ringing, routed, type Vapid, type Apns, type Account, type Doors } from '../box/index.ts';
 export { Clock, CLOCK, setupClock, placeClock, readSchedule, parseCron, nextFire, civil, fromCivil, type Schedule, type Fire, type Cron, type Civil } from './clock.ts';
 export { sanitise, hint, hintFor, groups, type Look, type Hint } from './look.ts';
+import { User } from './user.ts';
+import { Desk } from './desk.ts';
+import { Avatar } from './avatar.ts';
+import { Presence } from './presence.ts';
+import { Clock } from './clock.ts';
+import { Courier } from './courier.ts';
+import { Porter } from './porter.ts';
+import { Doorbell } from './doorbell.ts';
+export declare const BEINGS: {
+    beings: {
+        User: typeof User;
+        Desk: typeof Desk;
+        Avatar: typeof Avatar;
+        Presence: typeof Presence;
+        Clock: typeof Clock;
+        Courier: typeof Courier;
+        Porter: typeof Porter;
+        Doorbell: typeof Doorbell;
+    };
+};

package/dist/beings/index.js

@@ -4,13 +4,24 @@ export { User, DESK, HOME, BELL } from './user.js';
 export { Desk } from './desk.js';
 export { WAY, kindOf, verified, VERIFY, SEND } from './way.js';
 export { Avatar, USER, PUSHER } from './avatar.js';
-export { Carrier } from './carry.js';
+export { carry, blueprint, CARRIES } from './carry.js';
 export { Presence } from './presence.js';
 export { Courier, MOVER, isMoving } from './courier.js';
 export { Porter } from './porter.js';
 export { Doorbell } from './doorbell.js';
-export { Envoy, owner, occupant } from './envoy.js';
-export { DOCK, CONSOLE, LOCAL, LOCATION, NOTIFICATIONS, PUSH, TIMER, FACULTIES, FACULTY_CLASSES, Console, Faculty, Local, Location, Notifications, Push, Timer, isToken, join, settled, stand, standOn, lending, facultyOf } from '../dock/index.js';
-export { webPush, mintVapid, publicOf, apnsPush, pkcs8, HOSTS, fcmPush, isAccount, DOORS, handedTo, ringing, routed } from '../dock/index.js';
+export { BOX, BOX_SEED, Dock, LOCAL, LOCATION, NOTIFICATIONS, PUSH, TIMER, Faculty, Local, Location, Notifications, Push, Timer, contract, covers, nameOf, titleOf, keyed, join, settled, stand, standHarbor, classes, lent } from '../box/index.js';
+export { isToken } from '../box/index.js';
+export { webPush, mintVapid, publicOf, apnsPush, pkcs8, HOSTS, fcmPush, isAccount, DOORS, handedTo, ringing, routed } from '../box/index.js';
 export { Clock, CLOCK, setupClock, placeClock, readSchedule, parseCron, nextFire, civil, fromCivil } from './clock.js';
 export { sanitise, hint, hintFor, groups } from './look.js';
+import { User } from './user.js';
+import { Desk } from './desk.js';
+import { Avatar } from './avatar.js';
+import { Presence } from './presence.js';
+import { Clock } from './clock.js';
+import { Courier } from './courier.js';
+import { Porter } from './porter.js';
+import { Doorbell } from './doorbell.js';
+// The beings this folder brings to every harbor, as a tree: a ward names
+// one by where it lives, `beings/User`, as it names a faculty.
+export const BEINGS = { beings: { User, Desk, Avatar, Presence, Clock, Courier, Porter, Doorbell } };

package/dist/beings/join.d.ts

@@ -1,6 +1,7 @@
 import type { Hosted } from 'nervur/harbor';
 import type { Invitation } from 'nervur';
 import type { Avatar } from './avatar.ts';
+export declare const isIdentity: (hosted: Hosted, identity: unknown) => identity is string;
 export declare function avatarOf(hosted: Hosted, identity: string): Promise<{
     avatar?: Avatar;
     error?: string;

package/dist/beings/join.js

@@ -1,12 +1,14 @@
-// Her avatar in a ward, found or booted under the identity's key. An
-// identity is a word, and never a being of the ward.
+// An identity is a word, and never the key of a being the ward holds: the
+// ward is asked, so no route names who its beings are.
+export const isIdentity = (hosted, identity) => typeof identity === 'string' && /^[\w.-]+$/.test(identity) && !hosted.keys().includes(identity);
+// Her avatar in a ward, found or booted under the identity's key.
 export async function avatarOf(hosted, identity) {
-    if (!/^[\w.-]+$/.test(identity) || identity === hosted.record.user || identity === 'desk')
+    if (!isIdentity(hosted, identity))
         return { error: 'an identity is a word, and not a being of the ward' };
     const key = `avatar:${identity}`;
     let avatar = hosted.being(key);
     if (!avatar) {
-        const out = (await hosted.ask('boot', { key, class: 'Avatar' }));
+        const out = (await hosted.ask('boot', { key, class: 'beings/Avatar' }));
         if (out.error)
             return { error: out.error };
         avatar = hosted.being(key);

package/dist/beings/link.d.ts

@@ -1,6 +1,5 @@
 import type { Invitation } from 'nervur';
 export declare const KEY = "nervur";
-export declare const PROOF = "proof";
 export declare function format(inv: Invitation): string;
 export declare function parse(hash: string): Invitation | null;
 export declare function parseProof(hash: string): {

package/dist/beings/link.js

@@ -5,7 +5,7 @@ export const KEY = 'nervur';
 // a query string is in every log and every referer, and one read of it is
 // one way in taken. `<kind>.<token>`, the kind the desk knows it by and the
 // token that door minted.
-export const PROOF = 'proof';
+const PROOF = 'proof';
 const HEX = (n) => `[0-9a-f]{${n}}`;
 const FULL = new RegExp(`^(${HEX(128)})\\.(${HEX(64)})\\.(${HEX(64)})$`);
 const PUBLIC = new RegExp(`^${HEX(128)}$`);

package/dist/beings/porter.js

@@ -14,6 +14,7 @@
 // harbor's, never hers and never the door's, and the count below is only so
 // that a loop in this session stops somewhere a human can see.
 import { Being, isSilence, isWord, wordOf } from 'nervur';
+import { Doorbell } from './doorbell.js';
 const ROOM = 64;
 export class Porter extends Being {
     static cells = { minted: 0 };
@@ -24,8 +25,11 @@ export class Porter extends Being {
         const minted = typeof this.cells.minted === 'number' ? this.cells.minted : 0;
         if (minted >= ROOM)
             return { error: 'this bell holds no more doorbells' };
+        // The class says where it lives and the porter reads it off her. A path
+        // spelled here would be the doorbell named by whoever boots her, which
+        // is a class described by someone who is not it.
         const key = `doorbell:${minted + 1}`;
-        const held = await this.boot('Doorbell', key, key);
+        const held = await this.boot(Doorbell.at, key, key);
         if (held === null)
             return { error: 'this bell could not make a doorbell' };
         this.cells.minted = minted + 1;

package/dist/beings/presence.d.ts

@@ -3,6 +3,7 @@ import { Avatar } from './avatar.ts';
 export declare class Presence extends Avatar {
     static carries(occupant: OccupantRecord | undefined, _asker: Asker): boolean;
     static skips(id: string): boolean;
+    static needs: import("nervur").Blueprint[];
     readonly lent: Promise<Record<string, string | null>>;
     constructor(stance: Stance);
 }