nervur 0.21.3 → 0.21.5

package/dist/browser/index.d.ts

@@ -29,6 +29,7 @@ export declare class BrowserTerrain extends PointerTerrain {
     #private;
     readonly where: string;
     constructor(parts?: BrowserParts);
+    get foreground(): boolean;
     claim(): Promise<void>;
     release(): Promise<void>;
 }

package/dist/browser/index.js

@@ -156,6 +156,14 @@ export class BrowserTerrain extends PointerTerrain {
         super({ entropy, loader: new HeldLoader(parts.modules ?? []), custody: new IdbCustody(where, entropy), memory: new IdbMemory(where), faculties: [webFaculty(), webPush], opens: [WEB_OPENING] });
         this.where = where;
     }
+    // A shared or a service worker outlives any one tab, and a service
+    // worker is woken for a push with none open. Anywhere else, a page or a
+    // worker a tab made, the harbor lives with that tab.
+    get foreground() {
+        const scope = globalThis;
+        const is = (name) => typeof scope[name] === 'function' && globalThis instanceof scope[name];
+        return !is('SharedWorkerGlobalScope') && !is('ServiceWorkerGlobalScope');
+    }
     async claim() {
         const locks = globalThis.navigator?.locks;
         if (!locks)

package/dist/contract/index.d.ts

@@ -34,6 +34,7 @@ export type Loaded = Module & {
 };
 export declare abstract class Loader {
     abstract load(from: string): Promise<Loaded | null>;
+    missing(_from: string): string | null;
 }
 export declare abstract class Carrier {
     abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;

package/dist/contract/index.js

@@ -22,6 +22,11 @@ export class Custody {
 // crosses a door and never lives in a cell, so it is the
 // one thing beside the seed a terrain hands in: a map, an import, a bundle.
 export class Loader {
+    // Why a name it found nothing under holds nothing, where it can say more
+    // than that: a bundle names that code comes from it alone.
+    missing(_from) {
+        return null;
+    }
 }
 // Bytes to a ward pk in; bytes, or null for nothing, out. A harbor hands a
 // terrain's carrier what it holds no route for; what it routes goes to its

package/dist/crypto/ed25519.js

@@ -1,14 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
-// Ed25519 signs, as RFC 8032 defines it, and verifies with the cofactorless
-// check. The spec names exactly where a check fails, and Web Crypto promises
-// none of the decoding rules, so they are held here before Web Crypto runs:
+// Ed25519 signs, as RFC 8032 defines it, by `@noble/curves` in every
+// engine, since an engine's Web Crypto may refuse a secret the curve takes,
+// and verifies with the cofactorless check the spec names, which the
+// library's own verify does not make. The decoding rules are held here:
 //
 //   a signature of any length but sixty-four
 //   an `s` at or above the group order
 //   an `R` that does not decode, or whose bytes are not its point's encoding
 //   a public key that does not decode, or whose y is at or above the prime
 //   a public key of small order, in any spelling
-import { importSecret, own, publicOf, subtle } from './subtle.js';
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { concat } from './bytes.js';
+import { own, subtle } from './subtle.js';
 const P = 2n ** 255n - 19n;
 const L = 2n ** 252n + 27742317777372353535851937790883648493n;
 const mod = (a) => ((a % P) + P) % P;
@@ -63,8 +66,14 @@ const smallOrder = (p) => {
         q = add(q, q);
     return q.x === 0n && q.y === q.z;
 };
-export const ed25519Public = async (secret) => publicOf(await importSecret('Ed25519', secret, ['sign']));
-export const sign = async (secret, message) => new Uint8Array(await subtle().sign('Ed25519', await importSecret('Ed25519', secret, ['sign']), own(message)));
+const secretOf = (secret) => {
+    if (secret.length !== 32)
+        throw new TypeError('a secret is thirty-two bytes');
+    return secret;
+};
+export const ed25519Public = async (secret) => ed25519.getPublicKey(secretOf(secret));
+export const sign = async (secret, message) => ed25519.sign(message, secretOf(secret));
+// The cofactorless check, `[s]B = R + [k]A`, on points decoded as above.
 export const verify = async (pk, message, signature) => {
     if (signature.length !== 64)
         return false;
@@ -73,13 +82,12 @@ export const verify = async (pk, message, signature) => {
         return false;
     if (decode(signature.subarray(0, 32)) === null)
         return false;
-    if (little(signature.subarray(32)) >= L)
-        return false;
-    try {
-        const imported = await subtle().importKey('raw', own(pk), { name: 'Ed25519' }, false, ['verify']);
-        return await subtle().verify('Ed25519', imported, own(signature), own(message));
-    }
-    catch {
+    const s = little(signature.subarray(32));
+    if (s >= L)
         return false;
-    }
+    const R = ed25519.Point.fromBytes(signature.subarray(0, 32));
+    const A = ed25519.Point.fromBytes(pk);
+    const hashed = new Uint8Array(await subtle().digest('SHA-512', own(concat(signature.subarray(0, 32), pk, message))));
+    const k = little(hashed) % L;
+    return ed25519.Point.BASE.multiplyUnsafe(s).equals(R.add(A.multiplyUnsafe(k)));
 };

package/dist/crypto/subtle.d.ts

@@ -1,10 +1,3 @@
 export declare const subtle: () => SubtleCrypto;
 export type Bytes = Uint8Array<ArrayBuffer>;
 export declare const own: (bytes: Uint8Array) => Bytes;
-declare const PKCS8: {
-    readonly Ed25519: '302e020100300506032b657004220420';
-    readonly X25519: '302e020100300506032b656e04220420';
-};
-export declare const importSecret: (curve: keyof typeof PKCS8, secret: Uint8Array, uses: KeyUsage[]) => Promise<CryptoKey>;
-export declare const publicOf: (key: CryptoKey) => Promise<Uint8Array>;
-export {};

package/dist/crypto/subtle.js

@@ -9,21 +9,3 @@ export const subtle = () => {
 };
 // Web Crypto takes a buffer it owns, so every input is copied into one.
 export const own = (bytes) => Uint8Array.from(bytes);
-// The PKCS#8 wrapping of a thirty-two byte secret, which is the whole of it
-// for both curves.
-const PKCS8 = { Ed25519: '302e020100300506032b657004220420', X25519: '302e020100300506032b656e04220420' };
-export const importSecret = (curve, secret, uses) => {
-    if (secret.length !== 32)
-        throw new TypeError('a secret is thirty-two bytes');
-    const prefix = Uint8Array.from(PKCS8[curve].match(/../g), (b) => parseInt(b, 16));
-    const wrapped = new Uint8Array(48);
-    wrapped.set(prefix);
-    wrapped.set(secret, 16);
-    return subtle().importKey('pkcs8', wrapped, { name: curve }, true, uses);
-};
-// Web Crypto gives a private key's public half only through a JWK.
-export const publicOf = async (key) => {
-    const { x } = await subtle().exportKey('jwk', key);
-    const binary = atob(x.replaceAll('-', '+').replaceAll('_', '/'));
-    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
-};

package/dist/crypto/x25519.js

@@ -1,18 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
-// X25519 agrees. A secret is thirty-two bytes, clamped by the function and
-// never before.
+// X25519 agrees, by `@noble/curves` in every engine, since an engine's Web
+// Crypto may refuse a secret the curve takes. A secret is thirty-two bytes,
+// clamped by the function and never before.
+import { x25519 } from '@noble/curves/ed25519.js';
 import { zero } from './bytes.js';
-import { importSecret, own, publicOf, subtle } from './subtle.js';
-export const x25519Public = async (secret) => publicOf(await importSecret('X25519', secret, ['deriveBits']));
+export const x25519Public = async (secret) => {
+    if (secret.length !== 32)
+        throw new TypeError('a secret is thirty-two bytes');
+    return x25519.getPublicKey(secret);
+};
 // The agreement, or null for a public key that takes no seal: one whose
-// agreement is thirty-two zero bytes, or one the terrain refuses to read.
+// agreement is thirty-two zero bytes.
 export const agree = async (secret, pk) => {
-    if (pk.length !== 32)
+    if (pk.length !== 32 || secret.length !== 32)
         return null;
     try {
-        const mine = await importSecret('X25519', secret, ['deriveBits']);
-        const theirs = await subtle().importKey('raw', own(pk), { name: 'X25519' }, false, []);
-        const shared = new Uint8Array(await subtle().deriveBits({ name: 'X25519', public: theirs }, mine, 256));
+        const shared = x25519.getSharedSecret(secret, pk);
         return zero(shared) ? null : shared;
     }
     catch {

package/dist/harbor/catalogue.d.ts

@@ -8,6 +8,7 @@ export type ModuleRow = {
 };
 export interface Cataloguing {
     load(from: string): Promise<Loaded | null>;
+    missing(from: string): string | null;
     check(modules: readonly Loaded[]): string | null;
     run(modules: readonly Loaded[]): string | null;
     stands(kinds: readonly string[]): boolean;

package/dist/harbor/catalogue.js

@@ -46,7 +46,7 @@ export class Catalogue extends Faculty {
             const refused = loaded instanceof Error
                 ? loaded.message
                 : loaded === null
-                    ? `not found at ${row.from}`
+                    ? (this.#harbor.missing(row.from) ?? `not found at ${row.from}`)
                     : loaded.module !== module
                         ? `${row.from} is module ${loaded.module}`
                         : this.#harbor.check([...this.#running.values(), loaded]);
@@ -64,7 +64,7 @@ export class Catalogue extends Faculty {
         if (loaded instanceof Error)
             return { error: loaded.message };
         if (loaded === null)
-            return { error: 'no such module' };
+            return { error: this.#harbor.missing(args.from) ?? 'no such module' };
         const running = new Map(this.#running);
         running.set(loaded.module, loaded);
         const refused = this.#harbor.run([...running.values()]);

package/dist/harbor/dock.d.ts

@@ -7,6 +7,7 @@ export interface Hosting {
     route(pk: string, at: readonly string[] | null): boolean;
     keep(): Promise<boolean>;
     failures(): Failures;
+    readonly foreground: boolean;
     sweep(): Promise<string[]>;
     grounds(kind: string): boolean;
     awaken(key: string): Promise<void>;

package/dist/harbor/dock.js

@@ -54,11 +54,16 @@ export class Dock extends WardBeing {
         super(stance);
         this.#hosting = hosting;
     }
-    // The census adds what did not stand, for whoever pilots.
+    // The census adds what did not stand, for whoever pilots, and whether
+    // the harbor lives only as long as a screen.
     describe(asker) {
         const blueprint = super.describe(asker);
-        if (pilots(asker, this.notes(asker)))
-            blueprint.notes.failed = this.#hosting.failures();
+        if (!pilots(asker, this.notes(asker)))
+            return blueprint;
+        const notes = blueprint.notes;
+        notes.failed = this.#hosting.failures();
+        if (this.#hosting.foreground)
+            notes.foreground = true;
         return blueprint;
     }
     get hosted() {

package/dist/harbor/harbor.d.ts

@@ -15,6 +15,7 @@ export declare class Harbor extends Carrier implements Hosting, Cataloguing, Res
     sweep(): Promise<string[]>;
     move(name: string, seed: string, from: string | undefined, to: string | undefined): Promise<string | null>;
     release(name: string, store: string | undefined): Promise<void>;
+    get foreground(): boolean;
     failures(): Failures;
     get box(): Ward;
     get dock(): Dock;
@@ -28,6 +29,7 @@ export declare class Harbor extends Carrier implements Hosting, Cataloguing, Res
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
     classOf(kind: string): BeingClass | undefined;
     load(from: string): Promise<Loaded | null>;
+    missing(from: string): string | null;
     check(modules: readonly Loaded[]): string | null;
     run(modules: readonly Loaded[]): string | null;
     stands(kinds: readonly string[]): boolean;

package/dist/harbor/harbor.js

@@ -153,6 +153,9 @@ export class Harbor extends Carrier {
             return being instanceof Store ? [[key, being]] : [];
         });
     }
+    get foreground() {
+        return this.terrain.foreground;
+    }
     // Hosting: what did not stand when the harbor opened, each alone.
     failures() {
         return { wards: { ...this.#failed.wards }, routes: { ...this.#failed.routes } };
@@ -215,6 +218,9 @@ export class Harbor extends Carrier {
     load(from) {
         return this.terrain.loader.load(from);
     }
+    missing(from) {
+        return this.terrain.loader.missing(from);
+    }
     check(modules) {
         return Registry.refusal(this.#kit, modules);
     }

package/dist/harbor/terrain.d.ts

@@ -15,6 +15,7 @@ export declare abstract class Terrain {
     readonly faculties: readonly GroundFaculty[];
     readonly opens: readonly Opening[];
     readonly wakes: boolean;
+    get foreground(): boolean;
     claim(): Promise<void>;
     stand(_harbor: Harbor): Promise<void>;
     release(): Promise<void>;

package/dist/harbor/terrain.js

@@ -6,6 +6,12 @@ export class Terrain {
     // Whether its carriers wake and listen where their cells say. A harbor
     // opened for one ask and closed again dials and hears nothing.
     wakes = true;
+    // Whether the harbor lives only as long as a screen: a tab's, or a worker
+    // one tab owns. It is reached only while that screen is open, and hears
+    // no push, so its census says so.
+    get foreground() {
+        return false;
+    }
     // Before the harbor opens: a terrain whose ground another run holds
     // refuses here. Once it stands: whatever the ground serves beside it.
     // Once its carriers sleep: what that served, gone.

package/dist/pointer/bodies.d.ts

@@ -18,6 +18,7 @@ export declare class HeldLoader extends Loader {
     #private;
     constructor(modules?: readonly Module[]);
     load(from: string): Promise<Loaded | null>;
+    missing(from: string): string;
 }
 export declare class VolatileMemory extends Memory {
     #private;

package/dist/pointer/bodies.js

@@ -28,7 +28,9 @@ export class HeldCustody extends Custody {
         return Promise.resolve(this.#seed.slice());
     }
 }
-// Modules handed to this object, found by the name each declares.
+// Modules handed to this object, found by the name each declares: the
+// bundle a ground with no disk to load from carries, an edge's or a
+// browser's. A path, a package or any other name is no module of it.
 export class HeldLoader extends Loader {
     #modules = new Map();
     constructor(modules = []) {
@@ -40,6 +42,10 @@ export class HeldLoader extends Loader {
         const m = this.#modules.get(from);
         return Promise.resolve(m ? { module: m.module, version: m.version, classes: m.classes, from } : null);
     }
+    missing(from) {
+        const carried = [...this.#modules.keys()];
+        return `${from} is no module this bundle carries${carried.length === 0 ? ', and it carries none' : `: it carries ${carried.join(', ')}`}`;
+    }
 }
 // Entries that live as long as this object, copied in and out, which is
 // what a restart in one process finds.

package/dist/proof/law.js

@@ -194,7 +194,7 @@ export const lawScenes = (t, expect) => [
             expect.same(lost.names, ['w'], 'the rest of the harbor stands');
             expect.same((await census(lost)).beings.echo?.absent, true);
             expect.same(await lost.root('ask', { being: 'catalogue', method: 'modules' }), {
-                answer: { [law.module]: { version: '1', running: null, from: law.module, failed: `not found at ${law.module}` } },
+                answer: { [law.module]: { version: '1', running: null, from: law.module, failed: `${law.module} is no module this bundle carries, and it carries none` } },
             });
             const again = await world.restart('h', { ...t.again(bodies), loader: new HeldLoader([law]) });
             expect.same((await census(again)).beings.echo?.absent, false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.21.3",
+  "version": "0.21.5",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is.",
   "keywords": [
     "quo",
@@ -64,6 +64,7 @@
     "node": ">=22.18"
   },
   "dependencies": {
+    "@noble/curves": "2.4.0",
     "@noble/post-quantum": "0.7.1"
   },
   "publishConfig": {

package/src/browser/index.ts

@@ -175,6 +175,15 @@ export class BrowserTerrain extends PointerTerrain {
     this.where = where;
   }
 
+  // A shared or a service worker outlives any one tab, and a service
+  // worker is woken for a push with none open. Anywhere else, a page or a
+  // worker a tab made, the harbor lives with that tab.
+  override get foreground(): boolean {
+    const scope = globalThis as unknown as Record<string, unknown>;
+    const is = (name: string): boolean => typeof scope[name] === 'function' && globalThis instanceof (scope[name] as new () => unknown);
+    return !is('SharedWorkerGlobalScope') && !is('ServiceWorkerGlobalScope');
+  }
+
   override async claim(): Promise<void> {
     const locks = (globalThis as { navigator?: { locks?: LockManager } }).navigator?.locks;
     if (!locks) return;

package/src/contract/index.ts

@@ -67,6 +67,11 @@ export type Loaded = Module & { readonly from: string };
 // one thing beside the seed a terrain hands in: a map, an import, a bundle.
 export abstract class Loader {
   abstract load(from: string): Promise<Loaded | null>;
+  // Why a name it found nothing under holds nothing, where it can say more
+  // than that: a bundle names that code comes from it alone.
+  missing(_from: string): string | null {
+    return null;
+  }
 }
 
 // Bytes to a ward pk in; bytes, or null for nothing, out. A harbor hands a

package/src/crypto/ed25519.ts

@@ -1,14 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
-// Ed25519 signs, as RFC 8032 defines it, and verifies with the cofactorless
-// check. The spec names exactly where a check fails, and Web Crypto promises
-// none of the decoding rules, so they are held here before Web Crypto runs:
+// Ed25519 signs, as RFC 8032 defines it, by `@noble/curves` in every
+// engine, since an engine's Web Crypto may refuse a secret the curve takes,
+// and verifies with the cofactorless check the spec names, which the
+// library's own verify does not make. The decoding rules are held here:
 //
 //   a signature of any length but sixty-four
 //   an `s` at or above the group order
 //   an `R` that does not decode, or whose bytes are not its point's encoding
 //   a public key that does not decode, or whose y is at or above the prime
 //   a public key of small order, in any spelling
-import { importSecret, own, publicOf, subtle } from './subtle.ts';
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { concat } from './bytes.ts';
+import { own, subtle } from './subtle.ts';
 
 const P = 2n ** 255n - 19n;
 const L = 2n ** 252n + 27742317777372353535851937790883648493n;
@@ -64,21 +67,26 @@ const smallOrder = (p: Point): boolean => {
   return q.x === 0n && q.y === q.z;
 };
 
-export const ed25519Public = async (secret: Uint8Array): Promise<Uint8Array> => publicOf(await importSecret('Ed25519', secret, ['sign']));
+const secretOf = (secret: Uint8Array): Uint8Array => {
+  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
+  return secret;
+};
+
+export const ed25519Public = async (secret: Uint8Array): Promise<Uint8Array> => ed25519.getPublicKey(secretOf(secret));
 
-export const sign = async (secret: Uint8Array, message: Uint8Array): Promise<Uint8Array> =>
-  new Uint8Array(await subtle().sign('Ed25519', await importSecret('Ed25519', secret, ['sign']), own(message)));
+export const sign = async (secret: Uint8Array, message: Uint8Array): Promise<Uint8Array> => ed25519.sign(message, secretOf(secret));
 
+// The cofactorless check, `[s]B = R + [k]A`, on points decoded as above.
 export const verify = async (pk: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean> => {
   if (signature.length !== 64) return false;
   const key = decode(pk);
   if (key === null || smallOrder(key)) return false;
   if (decode(signature.subarray(0, 32)) === null) return false;
-  if (little(signature.subarray(32)) >= L) return false;
-  try {
-    const imported = await subtle().importKey('raw', own(pk), { name: 'Ed25519' }, false, ['verify']);
-    return await subtle().verify('Ed25519', imported, own(signature), own(message));
-  } catch {
-    return false;
-  }
+  const s = little(signature.subarray(32));
+  if (s >= L) return false;
+  const R = ed25519.Point.fromBytes(signature.subarray(0, 32));
+  const A = ed25519.Point.fromBytes(pk);
+  const hashed = new Uint8Array(await subtle().digest('SHA-512', own(concat(signature.subarray(0, 32), pk, message))));
+  const k = little(hashed) % L;
+  return ed25519.Point.BASE.multiplyUnsafe(s).equals(R.add(A.multiplyUnsafe(k)));
 };

package/src/crypto/subtle.ts

@@ -11,23 +11,3 @@ export type Bytes = Uint8Array<ArrayBuffer>;
 
 // Web Crypto takes a buffer it owns, so every input is copied into one.
 export const own = (bytes: Uint8Array): Bytes => Uint8Array.from(bytes);
-
-// The PKCS#8 wrapping of a thirty-two byte secret, which is the whole of it
-// for both curves.
-const PKCS8 = { Ed25519: '302e020100300506032b657004220420', X25519: '302e020100300506032b656e04220420' } as const;
-
-export const importSecret = (curve: keyof typeof PKCS8, secret: Uint8Array, uses: KeyUsage[]): Promise<CryptoKey> => {
-  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
-  const prefix = Uint8Array.from(PKCS8[curve].match(/../g)!, (b) => parseInt(b, 16));
-  const wrapped = new Uint8Array(48);
-  wrapped.set(prefix);
-  wrapped.set(secret, 16);
-  return subtle().importKey('pkcs8', wrapped, { name: curve }, true, uses);
-};
-
-// Web Crypto gives a private key's public half only through a JWK.
-export const publicOf = async (key: CryptoKey): Promise<Uint8Array> => {
-  const { x } = await subtle().exportKey('jwk', key);
-  const binary = atob(x!.replaceAll('-', '+').replaceAll('_', '/'));
-  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
-};

package/src/crypto/x25519.ts

@@ -1,19 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
-// X25519 agrees. A secret is thirty-two bytes, clamped by the function and
-// never before.
+// X25519 agrees, by `@noble/curves` in every engine, since an engine's Web
+// Crypto may refuse a secret the curve takes. A secret is thirty-two bytes,
+// clamped by the function and never before.
+import { x25519 } from '@noble/curves/ed25519.js';
 import { zero } from './bytes.ts';
-import { importSecret, own, publicOf, subtle } from './subtle.ts';
 
-export const x25519Public = async (secret: Uint8Array): Promise<Uint8Array> => publicOf(await importSecret('X25519', secret, ['deriveBits']));
+export const x25519Public = async (secret: Uint8Array): Promise<Uint8Array> => {
+  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
+  return x25519.getPublicKey(secret);
+};
 
 // The agreement, or null for a public key that takes no seal: one whose
-// agreement is thirty-two zero bytes, or one the terrain refuses to read.
+// agreement is thirty-two zero bytes.
 export const agree = async (secret: Uint8Array, pk: Uint8Array): Promise<Uint8Array | null> => {
-  if (pk.length !== 32) return null;
+  if (pk.length !== 32 || secret.length !== 32) return null;
   try {
-    const mine = await importSecret('X25519', secret, ['deriveBits']);
-    const theirs = await subtle().importKey('raw', own(pk), { name: 'X25519' }, false, []);
-    const shared = new Uint8Array(await subtle().deriveBits({ name: 'X25519', public: theirs }, mine, 256));
+    const shared = x25519.getSharedSecret(secret, pk);
     return zero(shared) ? null : shared;
   } catch {
     return null;

package/src/harbor/catalogue.ts

@@ -29,6 +29,8 @@ export type ModuleRow = { version: string; from: string; kinds: string[] };
 // What the catalogue asks of her harbor.
 export interface Cataloguing {
   load(from: string): Promise<Loaded | null>;
+  // Why nothing loads from a name, where the loader says more.
+  missing(from: string): string | null;
   // Why these modules cannot run together, or null.
   check(modules: readonly Loaded[]): string | null;
   // The modules run from now on, or why they cannot be.
@@ -72,7 +74,7 @@ export class Catalogue extends Faculty {
         loaded instanceof Error
           ? loaded.message
           : loaded === null
-            ? `not found at ${row.from}`
+            ? (this.#harbor.missing(row.from) ?? `not found at ${row.from}`)
             : loaded.module !== module
               ? `${row.from} is module ${loaded.module}`
               : this.#harbor.check([...this.#running.values(), loaded]);
@@ -86,7 +88,7 @@ export class Catalogue extends Faculty {
     if (!text(args.from)) return { error: 'from is text' };
     const loaded = await this.#harbor.load(args.from).catch((e: Error) => e);
     if (loaded instanceof Error) return { error: loaded.message };
-    if (loaded === null) return { error: 'no such module' };
+    if (loaded === null) return { error: this.#harbor.missing(args.from) ?? 'no such module' };
     const running = new Map(this.#running);
     running.set(loaded.module, loaded);
     const refused = this.#harbor.run([...running.values()]);

package/src/harbor/dock.ts

@@ -46,6 +46,8 @@ export interface Hosting {
   keep(): Promise<boolean>;
   // What did not stand when the harbor opened.
   failures(): Failures;
+  // Whether the harbor lives only as long as a screen.
+  readonly foreground: boolean;
   // Every place of the memory the dock does not name, gone.
   sweep(): Promise<string[]>;
   // Whether a kind is a carrier this harbor's ground ships.
@@ -92,10 +94,14 @@ export class Dock extends WardBeing implements Lender {
     this.#hosting = hosting;
   }
 
-  // The census adds what did not stand, for whoever pilots.
+  // The census adds what did not stand, for whoever pilots, and whether
+  // the harbor lives only as long as a screen.
   override describe(asker: Asker): Blueprint {
     const blueprint = super.describe(asker);
-    if (pilots(asker, this.notes(asker))) (blueprint.notes as JsonObject).failed = this.#hosting.failures();
+    if (!pilots(asker, this.notes(asker))) return blueprint;
+    const notes = blueprint.notes as JsonObject;
+    notes.failed = this.#hosting.failures();
+    if (this.#hosting.foreground) notes.foreground = true;
     return blueprint;
   }
 

package/src/harbor/harbor.ts

@@ -175,6 +175,10 @@ export class Harbor extends Carrier implements Hosting, Cataloguing, Resolving {
     });
   }
 
+  get foreground(): boolean {
+    return this.terrain.foreground;
+  }
+
   // Hosting: what did not stand when the harbor opened, each alone.
   failures(): Failures {
     return { wards: { ...this.#failed.wards }, routes: { ...this.#failed.routes } };
@@ -246,6 +250,10 @@ export class Harbor extends Carrier implements Hosting, Cataloguing, Resolving {
     return this.terrain.loader.load(from);
   }
 
+  missing(from: string): string | null {
+    return this.terrain.loader.missing(from);
+  }
+
   check(modules: readonly Loaded[]): string | null {
     return Registry.refusal(this.#kit, modules);
   }

package/src/harbor/terrain.ts

@@ -25,6 +25,12 @@ export abstract class Terrain {
   // Whether its carriers wake and listen where their cells say. A harbor
   // opened for one ask and closed again dials and hears nothing.
   readonly wakes: boolean = true;
+  // Whether the harbor lives only as long as a screen: a tab's, or a worker
+  // one tab owns. It is reached only while that screen is open, and hears
+  // no push, so its census says so.
+  get foreground(): boolean {
+    return false;
+  }
 
   // Before the harbor opens: a terrain whose ground another run holds
   // refuses here. Once it stands: whatever the ground serves beside it.

package/src/pointer/bodies.ts

@@ -32,7 +32,9 @@ export class HeldCustody extends Custody {
   }
 }
 
-// Modules handed to this object, found by the name each declares.
+// Modules handed to this object, found by the name each declares: the
+// bundle a ground with no disk to load from carries, an edge's or a
+// browser's. A path, a package or any other name is no module of it.
 export class HeldLoader extends Loader {
   readonly #modules = new Map<string, Module>();
   constructor(modules: readonly Module[] = []) {
@@ -43,6 +45,10 @@ export class HeldLoader extends Loader {
     const m = this.#modules.get(from);
     return Promise.resolve(m ? { module: m.module, version: m.version, classes: m.classes, from } : null);
   }
+  override missing(from: string): string {
+    const carried = [...this.#modules.keys()];
+    return `${from} is no module this bundle carries${carried.length === 0 ? ', and it carries none' : `: it carries ${carried.join(', ')}`}`;
+  }
 }
 
 // Entries that live as long as this object, copied in and out, which is

package/src/proof/law.ts

@@ -203,7 +203,7 @@ export const lawScenes = (t: Terrain, expect: Expect): [string, () => Promise<vo
       expect.same(lost.names, ['w'], 'the rest of the harbor stands');
       expect.same(((await census(lost)) as { beings: Record<string, { absent: boolean }> }).beings.echo?.absent, true);
       expect.same(await lost.root('ask', { being: 'catalogue', method: 'modules' }), {
-        answer: { [law.module]: { version: '1', running: null, from: law.module, failed: `not found at ${law.module}` } },
+        answer: { [law.module]: { version: '1', running: null, from: law.module, failed: `${law.module} is no module this bundle carries, and it carries none` } },
       });
       const again = await world.restart('h', { ...t.again(bodies), loader: new HeldLoader([law]) });
       expect.same(((await census(again)) as { beings: Record<string, { absent: boolean }> }).beings.echo?.absent, false);