@nervur-org/dock 0.5.0 → 0.6.0

package/dist/human/wake.d.ts

@@ -1,6 +1,6 @@
 import type { Invitation, JsonObject } from 'nervur';
 import type { Harbor } from 'nervur/harbor';
-import { type Token } from '../dock/index.ts';
+import { type Token } from '../box/index.ts';
 export declare const webToken: (endpoint: string, p256dh?: string, auth?: string) => {
     kind: string;
     endpoint: string;
@@ -19,7 +19,10 @@ export type Held = {
         banner: string;
     } | null>;
 };
-export declare function doorbell(harbor: Harbor, bell?: Bell): Promise<Held | null>;
+export type Why = 'unbuilt' | 'unhoused' | 'unanswered' | 'unmade' | 'untaken';
+export declare function doorbell(harbor: Harbor, bell?: Bell, note?: {
+    why?: Why;
+}): Promise<Held | null>;
 export declare function told(rel: {
     call(name: string, args?: JsonObject): Promise<unknown>;
 }, at: Held | null, token?: Token | null): Promise<string | null>;

package/dist/human/wake.js

@@ -18,8 +18,8 @@
 // browser endpoint is rung only by whoever holds the VAPID secret the
 // subscription was made under, and that secret is the world's own.
 import { isInvitation, isSilence, isWord } from 'nervur';
-import { DOCK, CONSOLE, NOTIFICATIONS, facultyOf } from '../dock/index.js';
-import { banner } from '../dock/push.js';
+import { BOX, BOX_SEED, NOTIFICATIONS, Notifications, lent } from '../box/index.js';
+import { banner } from '../box/ring.js';
 import { localName, relations } from './worlds.js';
 // The token a browser's push service hands a page: the endpoint, and the
 // two keys of the subscription made at it. RFC 8291 encrypts a body to
@@ -31,7 +31,7 @@ export const DOORBELL = 'doorbell';
 const said = (out) => (out === undefined || isSilence(out) || isWord(out) || out === null || typeof out !== 'object' || Array.isArray(out) ? null : out);
 // The box's own being, as the device's own code reaches its own object in
 // its own process. Nothing of this crosses an edge.
-const box = (harbor) => harbor.wards.get(DOCK)?.being(CONSOLE);
+const box = (harbor) => harbor.wards.get(BOX_SEED)?.being(BOX);
 // The doorbell this device holds, taken the first time and kept after that.
 // A stranger phone knocks the bell's public being, is booted a doorbell of
 // its own and comes away with the one way in; the standing lives on the
@@ -39,30 +39,39 @@ const box = (harbor) => harbor.wards.get(DOCK)?.being(CONSOLE);
 //
 // Null is a device with no bell behind it, which is what a build that names
 // none looks like and what a bell that will not answer looks like. Each of
-// them works in every other way.
-export async function doorbell(harbor, bell) {
-    if (!bell)
+// them works in every other way. The reason comes back beside the null, in
+// `note`, so a caller that wants to know which of them it is can ask and one
+// that does not passes nothing.
+export async function doorbell(harbor, bell, note) {
+    const no = (why) => {
+        if (note)
+            note.why = why;
         return null;
-    const ward = harbor.wards.get(DOCK);
+    };
+    if (!bell)
+        return no('unbuilt');
+    const ward = harbor.wards.get(BOX_SEED);
     const me = box(harbor);
     if (!ward || !me)
-        return null;
+        return no('unhoused');
     if (!me.standings[DOORBELL]) {
         const hello = said(await me.standings.knock({ ward: bell.pk }, 'hello', {}));
-        const inv = hello?.invitation;
+        if (!hello)
+            return no('unanswered');
+        const inv = hello.invitation;
         if (!isInvitation(inv))
-            return null;
+            return no('unmade');
         // The ward's own knock, which knocks and takes in one act: an
         // invitation is taken only where it was answered, so the two halves are
         // never split.
-        const took = said(await ward.ask('knock', { being: CONSOLE, id: DOORBELL, invitation: inv }));
+        const took = said(await ward.ask('knock', { being: BOX, id: DOORBELL, invitation: inv }));
         await ward.save();
         if (took?.taken !== DOORBELL)
-            return null;
+            return no('untaken');
     }
     const mine = me.standings[DOORBELL];
     if (!mine)
-        return null;
+        return no('untaken');
     return {
         keep: async (token) => {
             const out = said(await mine.ask('keep', { token }));
@@ -73,7 +82,7 @@ export async function doorbell(harbor, bell) {
             // The banner key is minted on the first ask and kept, and a terrain
             // whose banners are drawn by a second process plants the secret half
             // where that process reads it while this is happening.
-            const keys = facultyOf(harbor, NOTIFICATIONS);
+            const keys = await lent(harbor, NOTIFICATIONS);
             const key = keys ? said(await keys.banner({}))?.banner : undefined;
             if (typeof key !== 'string')
                 return null;

package/dist/human/web.d.ts

@@ -11,7 +11,6 @@ export type Folder = {
     serving(): Promise<boolean>;
     beings(): Promise<string | null>;
 };
-export declare const BARE_FOLDER: Folder;
 export type WebOptions = {
     at: {
         quo: string;

package/dist/human/web.js

@@ -1,11 +1,11 @@
-import { DOCK } from '../dock/index.js';
+import { BOX_SEED } from '../box/index.js';
 import { publicKey } from '../harbor/ward.js';
 import { ANDROID, APPLE, association } from './apps.js';
 import { door } from './door.js';
 import { BARE, CSS } from './style.js';
 // A world with nothing beside its wards: no design, no code of its own. It
 // is what a terrain hands the route when it holds no folder at all.
-export const BARE_FOLDER = {
+const BARE_FOLDER = {
     wearing: () => Promise.resolve({ tokens: false, fonts: false }),
     design: () => Promise.resolve(null),
     serving: () => Promise.resolve(false),
@@ -88,7 +88,7 @@ ${await design()}
     // public being still answers a proof and a link still knocks, but a hidden
     // ward's page is the plain door page and its root line is not written.
     const shown = o.shown ?? (() => true);
-    const wards = async () => Object.fromEntries(await Promise.all([...harbor.wards].filter(([n]) => n !== DOCK).map(async ([n, h]) => [n, { pk: h.pk, public: shown(n) && (await publicKey(h)) !== null }])));
+    const wards = async () => Object.fromEntries(await Promise.all([...harbor.wards].filter(([n]) => n !== BOX_SEED).map(async ([n, h]) => [n, { pk: h.pk, public: shown(n) && (await publicKey(h)) !== null }])));
     const config = async (ward, being) => ({ quo: o.at.quo, web: o.at.web, wards: await wards(), beings: await folder.serving(), ...(o.bell ? { bell: o.bell } : {}), ...(ward ? { ward } : {}), ...(being ? { being } : {}) });
     const tab = async (ward, being) => {
         return `<script id="nervur" type="application/json">${JSON.stringify(await config(ward, being)).replace(/</g, '\\u003c')}</script><script type="module" src="${o.at.web}/tab.js"></script>`;