@quo-systems/dock 0.2.1 → 0.2.2

package/dist/human/tab.js

@@ -1,27 +1,32 @@
 import { BrowserHarbor } from '../harbor/browser.js';
-import { Avatar, USER } from '../beings/avatar.js';
-import { parse, strip, isInvitation } from '../beings/link.js';
+import { USER } from '../beings/avatar.js';
+import { parse, strip } from '../beings/link.js';
 import { screenSide } from './screen.js';
 import { domSurface } from './dom.js';
 import { guest } from './guest.js';
-import { escape } from './html.js';
-const WORLDS = 'quo-worlds';
-const worlds = () => {
+import { door } from './door.js';
+import { world, relations, fresh } from './worlds.js';
+const kept = (key, fallback) => {
     try {
-        return JSON.parse(localStorage.getItem(WORLDS) ?? '{}');
+        return JSON.parse(localStorage.getItem(key) ?? 'null') ?? fallback;
     }
     catch {
-        return {};
+        return fallback;
     }
 };
-const remember = (pk, url, name) => {
+const keep = (key, value) => {
     try {
-        localStorage.setItem(WORLDS, JSON.stringify({ ...worlds(), [pk]: { url, name } }));
+        localStorage.setItem(key, JSON.stringify(value));
     }
     catch {
-        /* a tab with no storage still works, and forgets */
+        /* forgets */
     }
 };
+const WORLDS = 'quo-worlds';
+const worlds = () => kept(WORLDS, {});
+const remember = (pk, url, name) => keep(WORLDS, { ...worlds(), [pk]: { url, name } });
+const AT = (pk) => `quo-at:${pk}`;
+const NAMES = (pk) => `quo-names:${pk}`;
 const el = (tag, text = '', attrs = {}) => {
     const e = document.createElement(tag);
     if (text)
@@ -37,113 +42,141 @@ export async function start(cfg, root = document.body) {
     if (linked)
         history.replaceState(null, '', location.pathname + location.search + strip(location.hash));
     const nav = el('nav', '', { class: 'worlds' });
+    const who = el('nav', '', { class: 'relations' });
     const status = el('p', 'booting');
     const screen = el('div');
-    root.append(nav, status, screen);
+    root.append(nav, who, status, screen);
     const say = (s) => (status.textContent = s);
     // The harbor in the tab: one database per origin, one ward per world.
     const harbor = new BrowserHarbor('quo');
     await harbor.boot();
-    const name = `w-${cfg.pk.slice(0, 16)}`;
-    const ward = harbor.wards.get(name) ?? (await harbor.create(name, 'me'));
-    if (!ward.being('me'))
-        await ward.ask('boot', { key: 'me', class: 'Avatar' });
-    const me = ward.being('me');
     harbor.dial(cfg.quo);
+    // The world this page is about: the link's, since an invitation names
+    // its ward, or the page's own. A link for a world not on this harbor is
+    // a link to the wrong page, and says so.
+    const nameOf = (pk) => Object.keys(cfg.wards).find((n) => cfg.wards[n].pk === pk);
+    const pk = linked?.ward ?? (cfg.ward ? cfg.wards[cfg.ward]?.pk : undefined);
+    const wardName = pk ? nameOf(pk) : undefined;
+    const pageOf = (name) => `${new URL(cfg.web).pathname.replace(/\/$/, '')}/${encodeURIComponent(name)}`;
     const switcher = () => {
         nav.replaceChildren();
         const known = worlds();
-        for (const [pk, w] of Object.entries(known)) {
-            const a = el('a', w.name || pk.slice(0, 8), { href: w.url });
-            if (pk === cfg.pk)
+        for (const [k, w] of Object.entries(known)) {
+            const a = el('a', w.name || k.slice(0, 8), { href: w.url });
+            if (k === pk)
                 a.setAttribute('aria-current', 'page');
             nav.append(a);
         }
-        const here = worlds()[cfg.pk];
-        if (!here)
-            nav.append(el('span', `${cfg.ward} at ${new URL(cfg.web).host}`));
+        if (pk && !known[pk] && wardName)
+            nav.append(el('span', `${wardName} at ${new URL(cfg.web).host}`));
     };
     switcher();
-    // Joined: her page. Every call rotates her keys and a same-ward ask never
-    // crosses the harbor, so the side saves after each one.
-    const inside = async (notice) => {
+    if (!pk || !wardName) {
+        say(linked ? 'this link is for a world that does not live here' : 'choose a world');
+        return;
+    }
+    if (linked && location.pathname !== pageOf(wardName))
+        history.replaceState(null, '', pageOf(wardName) + location.search + location.hash);
+    const ward = await world(harbor, pk);
+    const at = { name: wardName, pk, public: cfg.wards[wardName].public };
+    // The relations in this world, and which one is on screen.
+    let side = null;
+    let current = null;
+    const names = () => kept(NAMES(pk), {});
+    const people = () => {
+        who.replaceChildren();
+        const rels = relations(ward);
+        const called = names();
+        for (const r of rels) {
+            const b = el('button', called[r.key] ?? r.key, { type: 'button' });
+            if (r.key === current?.key)
+                b.setAttribute('aria-current', 'true');
+            b.onclick = () => void inside(r, `in, as ${called[r.key] ?? r.key}`, called[r.key] ?? r.key);
+            who.append(b);
+        }
+        if (rels.length) {
+            const more = el('button', 'another way in', { type: 'button', class: 'another' });
+            more.onclick = () => void atDoor();
+            who.append(more);
+        }
+    };
+    // In, as one relation: her page. Every call rotates her keys and a
+    // same-ward ask never crosses the harbor, so the side saves after each.
+    const inside = async (rel, notice, called) => {
+        await side?.close();
         status.remove();
+        root.querySelector('form.password')?.remove();
         screen.replaceChildren();
-        const side = await screenSide(me, domSurface(screen), { after: () => ward.save(), notice });
-        remember(cfg.pk, location.origin + location.pathname, side.model.look.name || (typeof side.model.blueprint?.notes?.name === 'string' ? side.model.blueprint.notes.name : cfg.ward));
+        current = rel;
+        keep(AT(pk), rel.key);
+        const s = await screenSide(rel.avatar, domSurface(screen), { after: () => ward.save(), notice });
+        side = s;
+        const bp = s.model.blueprint;
+        const notesName = typeof bp?.notes?.name === 'string' ? bp.notes.name : '';
+        remember(pk, location.origin + pageOf(at.name), s.model.look.name || notesName || at.name);
+        if (!names()[rel.key])
+            keep(NAMES(pk), { ...names(), [rel.key]: called });
         switcher();
+        people();
     };
-    // The way in, from any of the three: join, save, and be inside.
-    const admit = async (inv, notice) => {
+    // The way in, from any of the three: a fresh avatar joins, the ward is
+    // saved, and she is the one on screen.
+    const admit = async (inv, notice, called) => {
         say('knocking');
-        const got = await me.join(inv);
+        const rel = await fresh(ward);
+        const got = await rel.avatar.join(inv);
         await ward.save(); // the knock went through her own door, which the harbor never sees
         if (!('asks' in got)) {
             say(`not in: ${got.error}`);
+            return false;
+        }
+        await inside(rel, notice, called);
+        return true;
+    };
+    // At the door. With a public being there, her describe as a page, and a
+    // form whose answer is an invitation lets the guest in. With nobody
+    // there, the door page: a link is the only way in, and nothing to type.
+    const atDoor = async () => {
+        await side?.close();
+        side = null;
+        current = null;
+        screen.replaceChildren();
+        if (!status.isConnected)
+            root.insertBefore(status, screen);
+        people();
+        if (!at.public) {
+            status.remove();
+            screen.innerHTML = door({ world: at.name, host: new URL(cfg.web).host });
             return;
         }
-        await inside(notice);
+        say(`at the door of ${at.name}`);
+        const rel = await fresh(ward);
+        const gate = guest(rel.avatar, pk);
+        const s = await screenSide(gate, domSurface(screen), {
+            after: () => ward.save(),
+            notice: `a guest at ${at.name}: what she shows strangers`,
+            admit: async (inv) => {
+                await s.close();
+                await admit(inv, `in, as a guest of ${at.name}`, 'guest');
+            },
+        });
+        side = s;
     };
-    // Already in: reconnect, nothing minted.
-    if (me.standings[USER]) {
-        const had = await me.tools();
+    // A link: one more relation, whoever else is in. Then whoever was on
+    // screen last, or the door.
+    if (linked && (await admit(linked, 'in, by the link', 'link')))
+        return;
+    const rels = relations(ward);
+    const last = kept(AT(pk), null);
+    const back = rels.find((r) => r.key === last) ?? rels[rels.length - 1];
+    if (back) {
+        const had = await back.avatar.tools();
+        await ward.save(); // her keys rotated on that ask, whatever it answered
         if ('asks' in had)
-            return inside('in, as before');
+            return inside(back, linked ? `not in by the link; in, as before` : 'in, as before', names()[back.key] ?? back.key);
         say(`not in (${had.error})`);
     }
-    if (linked)
-        return admit(linked, 'in, by the link');
-    // A guest: the public being's describe as a page; a form whose answer is
-    // an invitation lets the guest in.
-    say(`at the door of ${cfg.ward}`);
-    const door = guest(me, cfg.pk);
-    const side = await screenSide(door, domSurface(screen), {
-        after: () => ward.save(),
-        notice: `a guest at ${cfg.ward}: what she shows strangers`,
-        admit: async (inv) => {
-            await side.close();
-            await admit(inv, `in, as a guest of ${cfg.ward}`);
-        },
-    });
-    // The dock's own way in, when the desk is at the door: the owner password
-    // for a nonce, and the desk's `device` form submitted with it.
-    if (side.model.blueprint?.asks.some((a) => a.name === 'device')) {
-        const form = el('form', '', { class: 'password' });
-        const identity = el('input', '', { name: 'identity', value: 'tab', placeholder: 'identity' });
-        const password = el('input', '', { name: 'password', type: 'password', placeholder: 'owner password' });
-        const go = el('button', 'enter as the owner');
-        form.append(identity, password, go);
-        root.insertBefore(form, screen);
-        form.onsubmit = (ev) => {
-            ev.preventDefault();
-            void (async () => {
-                say('asking the world');
-                let res;
-                try {
-                    res = await fetch(`${cfg.web}/${encodeURIComponent(cfg.ward)}/login`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ password: password.value, identity: identity.value }) });
-                }
-                catch (e) {
-                    say(`the world did not answer: ${e.message}`);
-                    return;
-                }
-                password.value = '';
-                if (!res.ok) {
-                    say(`refused: ${(await res.json().catch(() => ({ error: res.status }))).error ?? res.status}`);
-                    return;
-                }
-                const { nonce } = (await res.json());
-                const inv = await door.call('device', { proof: { kind: 'tab', nonce } });
-                await ward.save();
-                if (!isInvitation(inv)) {
-                    say(`not in: ${escape(JSON.stringify(inv))}`);
-                    return;
-                }
-                form.remove();
-                await side.close();
-                await admit(inv, `in, as ${identity.value}`);
-            })();
-        };
-    }
+    await atDoor();
 }
 // The page hands the config in a JSON script, which a content security
 // policy allows where an inline script is not.

package/dist/human/web.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { DiskHarbor } from '../harbor/disk.ts';
+export type WebOptions = {
+    at: {
+        quo: string;
+        web: string;
+    };
+};
+export declare function webRoute(harbor: DiskHarbor, o: WebOptions): (req: IncomingMessage, res: ServerResponse, rest: string) => Promise<boolean>;

package/dist/human/web.js

@@ -0,0 +1,95 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+import { door } from './door.js';
+// The paths under `/web` that are the exchange's, never a ward's name.
+const RESERVED_PATHS = new Set(['login', 'allow', 'tab.js']);
+export function webRoute(harbor, o) {
+    const tabEntry = () => {
+        const js = fileURLToPath(new URL('./tab.js', import.meta.url));
+        return existsSync(js) ? js : fileURLToPath(new URL('./tab.ts', import.meta.url));
+    };
+    let bundle;
+    const built = () => (bundle ??= build({ entryPoints: [tabEntry()], bundle: true, format: 'esm', platform: 'browser', target: 'es2023', write: false }).then((out) => out.outputFiles[0].text));
+    const quoOrigin = (() => {
+        try {
+            const u = new URL(o.at.quo);
+            return `${u.origin} ${u.origin.replace(/^http/, 'ws')}`;
+        }
+        catch {
+            return '';
+        }
+    })();
+    const host = (() => {
+        try {
+            return new URL(o.at.web).host;
+        }
+        catch {
+            return o.at.web;
+        }
+    })();
+    const policy = `default-src 'none'; script-src 'self'; style-src 'unsafe-inline'; img-src 'self' data:; connect-src 'self' ${quoOrigin}; form-action 'self'; base-uri 'none'; frame-ancestors 'none'`;
+    const shell = (body) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>quo</title>
+<style>${CSS}</style>
+</head><body>${body}</body></html>`;
+    const esc = (v) => v.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c] ?? c);
+    const publicOf = (h) => h.partition.public ?? null;
+    const html = (status, res, body) => {
+        res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'content-security-policy': policy, 'referrer-policy': 'no-referrer' });
+        res.end(shell(body));
+        return true;
+    };
+    const wards = () => Object.fromEntries([...harbor.wards].map(([n, h]) => [n, { pk: h.pk, public: publicOf(h) !== null }]));
+    const tab = (ward) => {
+        const cfg = { quo: o.at.quo, web: o.at.web, wards: wards(), ...(ward ? { ward } : {}) };
+        return `<script id="quo" type="application/json">${JSON.stringify(cfg).replace(/</g, '\\u003c')}</script><script type="module" src="${o.at.web}/tab.js"></script>`;
+    };
+    return async (req, res, rest) => {
+        const parts = rest.split('/').filter(Boolean);
+        if (req.method === 'GET' && (rest === '' || rest === '/')) {
+            const list = [...harbor.wards]
+                .filter(([, h]) => publicOf(h) !== null)
+                .map(([n, h]) => `<li><a href="${o.at.web}/${encodeURIComponent(n)}">${esc(n)}</a> <small>${esc(publicOf(h) ?? '')} at the door, <code>${h.pk.slice(0, 16)}…</code></small></li>`)
+                .join('');
+            return html(200, res, `${list ? `<h1>worlds</h1><ul>${list}</ul>` : door({ host })}${tab()}`);
+        }
+        if (rest === '/tab.js' && req.method === 'GET') {
+            res.writeHead(200, { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': 'no-store' });
+            res.end(await built());
+            return true;
+        }
+        const wardName = parts[0] ?? '';
+        if (!wardName || RESERVED_PATHS.has(wardName))
+            return false;
+        const hosted = harbor.wards.get(wardName);
+        if (!hosted)
+            return html(404, res, `<h1>no such world</h1><p>no ward named ${esc(wardName)} on this harbor.</p>`);
+        if (parts.length === 1 && req.method === 'GET')
+            return html(200, res, tab(wardName));
+        return false;
+    };
+}
+// The tab's stylesheet: one, light and dark, honouring the variables a look
+// sets on a section. The page owns layout; a far being paints inside her
+// section and nowhere else. The door page is the one designed thing in it.
+const CSS = [
+    ':root{color-scheme:light dark;--accent:#3b6ef5;--bg:transparent;--fg:inherit;--font:system-ui,sans-serif;--radius:6px;--ink:#1c1b22;--paper:#fbfaf7;--mute:#6b6a73}',
+    '@media(prefers-color-scheme:dark){:root{--ink:#ecebe6;--paper:#141318;--mute:#9a99a2}}',
+    'html{background:var(--paper);color:var(--ink)}',
+    'body{font:16px/1.5 system-ui,sans-serif;max-width:40rem;margin:2rem auto;padding:0 1rem}',
+    'nav.worlds{display:flex;flex-wrap:wrap;gap:.5rem 1rem;font-size:.9rem;opacity:.8}nav.worlds a[aria-current]{font-weight:600}',
+    'nav.relations{display:flex;flex-wrap:wrap;gap:.25rem;margin:.5rem 0}nav.relations button{background:transparent;color:inherit;border:1px solid color-mix(in srgb,currentColor 30%,transparent)}nav.relations button[aria-current]{border-color:var(--accent);font-weight:600}',
+    'header,main{background:var(--bg);color:var(--fg);font-family:var(--font)}header{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem 1rem}header .notice{width:100%;margin:0}',
+    'input,select,textarea,button{font:inherit;padding:.4rem;margin:.2rem;border-radius:var(--radius)}button{background:var(--accent);color:#fff;border:0;padding:.4rem .9rem}',
+    'fieldset{border:1px solid color-mix(in srgb,currentColor 20%,transparent);border-radius:var(--radius);margin:.5rem 0}',
+    'section.standing{background:var(--bg);color:var(--fg);font-family:var(--font);border-left:4px solid var(--accent);border-radius:var(--radius);padding:.25rem 1rem;margin:1.5rem 0}section.standing h2{display:flex;align-items:center;gap:.5rem;font-size:1.1rem}img.logo{height:1.6rem}',
+    'table{border-collapse:collapse}td,th{padding:.15rem .5rem;text-align:left}.answer{margin:.5rem 0 1rem;padding:.5rem;border-left:3px solid var(--accent)}.answer.error{border-color:#c33}.answer.silence,.answer.word,.answer.unreached{border-color:#c93}pre{padding:.75rem;overflow:auto}',
+    // the door page: one column, generous air, the mark, a word, a sentence
+    'main.door{min-height:70vh;display:flex;flex-direction:column;justify-content:center;align-items:flex-start;max-width:32rem;margin:0 auto;padding:3rem 0;font-family:ui-serif,Georgia,"Times New Roman",serif}',
+    'main.door .mark{width:3.5rem;height:3.5rem;color:var(--ink);opacity:.9;margin-bottom:1.25rem}',
+    'main.door h1{font-size:3rem;font-weight:400;letter-spacing:-.02em;line-height:1;margin:0 0 .5rem}',
+    'main.door .where{font-family:system-ui,sans-serif;font-size:.85rem;letter-spacing:.08em;text-transform:uppercase;color:var(--mute);margin:0 0 2rem}main.door .where span{text-transform:none;letter-spacing:0}',
+    'main.door .lead{font-size:1.5rem;line-height:1.3;margin:0 0 1rem}',
+    'main.door p{font-size:1.05rem;line-height:1.6;margin:0 0 1rem;max-width:30rem}',
+    'main.door .quiet{color:var(--mute);font-size:.95rem;border-top:1px solid color-mix(in srgb,currentColor 15%,transparent);padding-top:1rem;margin-top:1rem}',
+].join('');

package/dist/human/worlds.d.ts

@@ -0,0 +1,10 @@
+import type { Harbor, Hosted } from '@quo-systems/quo/harbor';
+import { Avatar } from '../beings/avatar.ts';
+export declare const localName: (pk: string) => string;
+export declare function world(harbor: Harbor, pk: string): Promise<Hosted>;
+export type Relation = {
+    key: string;
+    avatar: Avatar;
+};
+export declare function relations(ward: Hosted): Relation[];
+export declare function fresh(ward: Hosted): Promise<Relation>;

package/dist/human/worlds.js

@@ -0,0 +1,38 @@
+import { Avatar, USER } from '../beings/avatar.js';
+// The local ward for a far world, by its pk: created on first sight, on
+// the tab's own seed, empty.
+export const localName = (pk) => `w-${pk.slice(0, 16)}`;
+export async function world(harbor, pk) {
+    const name = localName(pk);
+    return harbor.wards.get(name) ?? (await harbor.create(name, 'me'));
+}
+export function relations(ward) {
+    const beings = ward.partition.beings ?? {};
+    const out = [];
+    for (const key of Object.keys(beings)) {
+        const a = ward.being(key);
+        if (a instanceof Avatar && a.standings[USER])
+            out.push({ key, avatar: a });
+    }
+    return out;
+}
+// An avatar for a relation not yet made: one who holds no standing, whether
+// left by a guest who never came in or booted now under the next free key.
+// She is the one who knocks, as a guest or with an invitation, and she
+// becomes a relation the moment she takes her standing.
+export async function fresh(ward) {
+    const beings = ward.partition.beings ?? {};
+    for (const key of Object.keys(beings)) {
+        const a = ward.being(key);
+        if (a instanceof Avatar && !a.standings[USER])
+            return { key, avatar: a };
+    }
+    let n = 1;
+    while (beings[`r${n}`])
+        n++;
+    const key = `r${n}`;
+    const out = (await ward.ask('boot', { key, class: 'Avatar' }));
+    if (out.error)
+        throw new Error(`the tab could not boot an avatar: ${out.error}`);
+    return { key, avatar: ward.being(key) };
+}

package/dist/mcp/route.d.ts

@@ -0,0 +1,12 @@
+import { OAuth } from './oauth.ts';
+import type { McpHttp } from './http.ts';
+import type { Handler } from '../cli/http.ts';
+export type Routes = {
+    mcp: string;
+    web: string;
+    quo?: string;
+};
+export declare function mcpRoute(dir: string, routes: Routes, mcp: McpHttp | null): Promise<{
+    oauth: OAuth;
+    handler: Handler;
+}>;

package/dist/mcp/route.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// The mcp. route: the credential exchange and the MCP endpoint, served by
+// the daemon under `/mcp` and mapped by the proxy from the mcp. hostname.
+// The OAuth store is `<dir>/oauth.json`, the route's own and never a
+// ward's: clients, pending requests, codes and tokens, each mapping to a
+// client identity at most. A bearer names an identity in a world; the
+// endpoint hands both to the model side, which runs beside her avatar.
+import { readFile, writeFile, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { OAuth, emptyStore } from './oauth.js';
+export async function mcpRoute(dir, routes, mcp) {
+    const file = join(dir, 'oauth.json');
+    const store = existsSync(file) ? { ...emptyStore(), ...JSON.parse(await readFile(file, 'utf8')) } : emptyStore();
+    let queue = Promise.resolve();
+    const persist = (s) => (queue = queue.then(async () => {
+        await writeFile(file + '.tmp', JSON.stringify(s), { mode: 0o600 });
+        await rename(file + '.tmp', file);
+    }));
+    const oauth = new OAuth({ issuer: routes.mcp, resource: `${routes.mcp}/mcp`, finish: (id) => `${routes.web}/login?request=${id}`, store, persist });
+    const handler = async (req, res, rest) => {
+        if (await oauth.handle(req, res, rest))
+            return;
+        if (rest === '/mcp') {
+            const grant = oauth.bearer(req);
+            if (grant === null || !mcp)
+                return oauth.challenge(res);
+            return mcp.handle(req, res, grant.identity, grant.ward);
+        }
+        res.writeHead(404, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: 'no such route' }));
+    };
+    return { oauth, handler };
+}

package/harbor/quo-harbor.md

@@ -200,14 +200,17 @@ rotation, and nothing else.
 
 ## Reach, directory, rendezvous
 
-A harbor needs three reach kinds and nothing more:
+A harbor needs two reach kinds and nothing more, which is what
+`packages/quo/SPEC.md` says and what `packages/quo/src/harbor/reach.ts` is:
 
 - **request**: a URL. Send bytes, get bytes. Listener to listener.
 - **socket**: a held connection, opened by whichever side can dial, used in
   both directions with a frame id. A WebSocket, a WebRTC channel and a
   native socket are one socket reach.
-- **channel**: an in-process port between two runtimes on one device. Tabs
-  on one machine, a webview and its sidecar.
+
+Two runtimes on one device are no third kind. Either they are one harbor,
+and it calls its other door with no transport at all, or they are two
+harbors, and one of them dials the other as any dialer does.
 
 Plus one forwarding rule: a pk whose reach is another harbor that holds a
 socket to it. That rule is the **rendezvous**, and with it every dialer is
@@ -260,7 +263,8 @@ rebinds it.
 The reach interface and its two implementations are the library's,
 `packages/quo/src/harbor/reach.ts`, and pass its reach suite here: the request
 and a socket to a daemon in `packages/dock/test/wire.test.ts`, the request
-through the worker inside the edge. The listener half is the terrain's, below:
+through the worker inside the edge. The listener half is the terrain's,
+`packages/dock/harbor/quo.ts`, the route the daemon mounts under `/quo`:
 
 ```
 request      POST <url>/<pk>, the sealed ask as the body, the sealed reply as the answer;
@@ -289,19 +293,18 @@ request. So a third harbor with a hint that a phone's pk is at acme's
 `quo serve --dial URL`, or `<dir>/dial.json`, makes a daemon a dialer: it
 holds one socket per URL, announces its wards on open, binds the listener's
 pks, and reconnects with backoff from a second to thirty when the line
-drops. A pk is 64 bytes on the wire, the ward key and the padlock, which the
-first version of the ask frame got wrong and the suite caught in one run.
+drops. A pk is 64 bytes on the wire, the ward key and the padlock.
 
 The proof is `packages/dock/test/wire.test.ts`: the library's conformance suite,
 untouched, against two disk harbors in two folders with HTTP doors on
 loopback, once with every ask a request and once with the second harbor
 dialing the first; down is the reach refused, migrate is the ward folder
-moved and adopted. Then the rendezvous on its own. What it taught: a harbor
-must write the partition before it lets a folder go, because a being driven
-in-process changes it without passing a door; listeners left open keep a
-test process alive forever, so every pair is closed after the file; and a
-proxy sends the route root as `/quo/`, trailing slash, which the door takes.
-The first live crossing, Mac to lab and back, is in `estates/lab/lab.md`.
+moved and adopted. Then the rendezvous on its own.
+
+Two rules the daemon obeys and a reader would otherwise rediscover: a harbor
+writes the partition before it lets a folder go, because a being driven
+in-process changes it without passing a door; and a proxy sends the route
+root as `/quo/`, with the trailing slash, which the door takes.
 
 ## The two cores, as built
 
@@ -338,7 +341,7 @@ harbors in one tab with two databases, both dialing a Node daemon on
 loopback, so every relation crosses the rendezvous; down is the reach
 refused on both, migrate lifts seed, partition and record from one database
 into the other and boots there, the tab-to-home scene. And the lock: a
-second harbor over one database does not boot. It passed on 2026-09-04.
+second harbor over one database does not boot.
 
 ## The edge, as built
 
@@ -370,11 +373,10 @@ against two edge harbors in one object over two prefixed views of its
 storage, reaching each other by request through the worker; the root door
 refused without the secret and answering under it; and a Node daemon
 dialing the edge, its pk held there, reached by a third harbor through the
-edge, unreached when the line drops. What it taught: one object may not
-touch another's storage, the platform says so at the first put, and so the
-two harbors of the exercise share an object the way two tabs share a page;
-and a Uint8Array over a shared buffer is refused by the platform's crypto,
-which wants a plain one.
+edge, unreached when the line drops. Two platform rules shape it: one object
+may not touch another's storage, so the exercise's two harbors share one
+object the way two tabs share a page; and the platform's crypto refuses a
+Uint8Array over a shared buffer and wants a plain one.
 
 The `ws` question the road asked is answered by this terrain: the socket
 reach's framing and the dialer are written on the standard surface and
@@ -399,10 +401,10 @@ device
     quo.sock                     owner asks; local only; never behind a proxy
     side.sock                    local sides; local only; never behind a proxy
     127.0.0.1:8787               the HTTP door, loopback only; routes mount by path
-      /health                    the wards it hosts, by name and pk
-      /mcp                       the model side
-      /web                       the bundle for tabs, and the exchange pages
-      /quo                       later: the socket door: request in, sockets held, the rendezvous
+      /health                    the wards it hosts, by name and pk; cli/http.ts
+      /mcp                       the model side; mcp/route.ts
+      /web                       the worlds' pages and the exchange; human/web.ts, mcp/web/
+      /quo                       the socket door: request in, sockets held, the rendezvous; harbor/quo.ts
   reverse proxy
     mcp.example.com -> 127.0.0.1:8787/mcp
     web.example.com -> 127.0.0.1:8787/web
@@ -426,15 +428,13 @@ There is no `cli.` route.
 
 ## Acceptance
 
-Every harbor here is accepted the day it passes the library's conformance suite
-untouched, and by nothing else. The disk harbor over the wire passed it on
-2026-09-04, under both reaches; the browser harbor through a daemon passed it
-the same day; the edge harbor inside the platform's runtime passed it the same
-day. Reach, store and the core now hold on three terrains, which is where the
-library takes them. Every store passes the library's store suite,
+A harbor here is accepted when it passes the library's conformance suite
+untouched, and by nothing else. Three do: the disk harbor over the wire
+under both reaches, the browser harbor through a daemon, and the edge harbor
+inside the platform's runtime. Every store passes the library's store suite,
 `packages/quo/src/conformance/store.ts`: files in
 `packages/dock/test/store.test.ts`, IndexedDB and the edge's storage inside
 their terrains behind `check:terrain`. Every reach passes the library's reach
 suite, `packages/quo/src/conformance/reach.ts`. The store, the reach and the
-core are in the library since 2026-09-04, each with `packages/quo/SPEC.md` in
-the same commit, and every harbor here is one of them over its own terrain.
+core are the library's, and every harbor here is one of them over its own
+terrain.