nervur 0.21.0 → 0.21.1

package/README.md

@@ -218,7 +218,11 @@ stands a ward under a seed you name, or a drawn one.
   and every class between it and `Faculty`.
 - **Entropy, Clock, Custody, Memory, Carrier, Loader.** The contracts a
   terrain fulfils. Each has one suite, and every body that fulfils it
-  passes it.
+  passes it. `nervur/proof` hands you those suites and the unpacking
+  law's as scenes, a title and a function each, so a body of your own,
+  a store in a cloud or a secret of your platform's, runs them under
+  your own runner: `for (const [title, scene] of memoryScenes('Mine',
+  make, expect)) test(title, scene)`. `@nervur-org/s3` is one such body.
 - **Harbor, Terrain, Dock, Catalogue, Registry, WardBeing.** The onion.
 - **World, PointerTerrain** and the pointer bodies, `HeldLoader` among
   them. A whole world with this package alone.
@@ -240,6 +244,8 @@ stands a ward under a seed you name, or a drawn one.
 - **WebDialer, webFaculty**: Quo over the web, a post to `https://` or a
   held line to `wss://`, in any engine with `fetch` and WebSocket.
   `webServe` and `webGround`, from `nervur/http`, listen for it on Node.
+  `answerPost(harbor, listen, request)` answers one post and nothing
+  more, for a function that opens a harbor per request and closes it.
 
 - **The relay**, `org.nervur.relay` and `org.nervur.relay-client`, in
   every harbor: a harbor nobody can dial is reached through one that

package/dist/contract/index.js

@@ -18,7 +18,8 @@ export class Memory {
 export class Custody {
 }
 // Code, by the name a harbor keeps for it, or null where this loader has
-// none. Code never crosses a door and never lives in a cell, so it is the
+// none. Code it has that does not load throws, saying why. Code never
+// 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 {
 }

package/dist/harbor/catalogue.js

@@ -42,8 +42,14 @@ export class Catalogue extends Faculty {
     // it. The rest stay out, each with its reason.
     async wake() {
         for (const [module, row] of Object.entries(this.#rows)) {
-            const loaded = await this.#harbor.load(row.from).catch(() => null);
-            const refused = loaded === null ? `not found at ${row.from}` : loaded.module !== module ? `${row.from} is module ${loaded.module}` : this.#harbor.check([...this.#running.values(), loaded]);
+            const loaded = await this.#harbor.load(row.from).catch((e) => e);
+            const refused = loaded instanceof Error
+                ? loaded.message
+                : loaded === null
+                    ? `not found at ${row.from}`
+                    : loaded.module !== module
+                        ? `${row.from} is module ${loaded.module}`
+                        : this.#harbor.check([...this.#running.values(), loaded]);
             if (refused === null)
                 this.#running.set(module, loaded);
             else
@@ -54,7 +60,9 @@ export class Catalogue extends Faculty {
     async add(args) {
         if (!text(args.from))
             return { error: 'from is text' };
-        const loaded = await this.#harbor.load(args.from);
+        const loaded = await this.#harbor.load(args.from).catch((e) => e);
+        if (loaded instanceof Error)
+            return { error: loaded.message };
         if (loaded === null)
             return { error: 'no such module' };
         const running = new Map(this.#running);

package/dist/harbor/dock.js

@@ -126,8 +126,12 @@ export class Dock extends WardBeing {
     }
     async host(args) {
         const name = args.ward;
-        if (!text(name) || name === BOX || this.hosted.some((h) => h.ward === name))
-            return { error: 'no such ward to host' };
+        if (!text(name))
+            return { error: 'ward is text' };
+        if (name === BOX)
+            return { error: 'box is the box ward' };
+        if (this.hosted.some((h) => h.ward === name))
+            return { error: `${name} is hosted already` };
         if (args.seed !== undefined && !text(args.seed))
             return { error: 'seed is text' };
         const invitation = await this.stance.occupants.invite(name, { hosted: true });

package/dist/node/index.js

@@ -53,8 +53,10 @@ export const isFile = (from) => /^(\.{1,2}[\\/]|[\\/]|[A-Za-z]:[\\/])/.test(from
 // Code from a file or an installed package: a module that exports
 // `module`, `version` and `classes`, found again by where it was found, a
 // file by its absolute path and a package by its name, resolved from each
-// folder of `bases` in order. What cannot be imported, or exports no
-// module, is none.
+// folder of `bases` in order. What is not there, or exports no module, is
+// none. Code that is there and does not import throws Node's reason, so
+// whoever added it learns why; an ES module read as CommonJS says which
+// field its package.json lacks.
 export class ImportLoader extends Loader {
     #bases;
     constructor(bases = [process.cwd()]) {
@@ -69,8 +71,14 @@ export class ImportLoader extends Loader {
         try {
             exported = (await import(__rewriteRelativeImportExtension(pathToFileURL(found).href)));
         }
-        catch {
-            return null;
+        catch (e) {
+            const said = e.message;
+            // The name itself is nowhere, as against code there that needs
+            // something that is not.
+            if (e.code === 'ERR_MODULE_NOT_FOUND' && said.includes(`'${found}'`))
+                return null;
+            const commonjs = e instanceof SyntaxError && /\b(export|import)\b/.test(said);
+            throw new Error(`${found} did not load: ${said}${commonjs ? '; it is an ES module read as CommonJS, so set "type": "module" in its package.json' : ''}`, { cause: e });
         }
         const { module, version, classes } = exported;
         if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes))

package/dist/proof/law.js

@@ -210,7 +210,7 @@ export const lawScenes = (t, expect) => [
             expect.same(again.names, ['good']);
             expect.same((await census(again)).failed, { wards: { bad: 'an entry the package did not seal' }, routes: {} });
             expect.same(await rootLine(again, { ward: 'bad' }), { error: 'the ward did not stand', reason: 'an entry the package did not seal' });
-            expect.same(await again.root('host', { ward: 'bad' }), { error: 'no such ward to host' }, 'its name and seed stay kept');
+            expect.same(await again.root('host', { ward: 'bad' }), { error: 'bad is hosted already' }, 'its name and seed stay kept');
             await spoil(places[1]);
             let refused = '';
             await world.restart('h', t.again(bodies)).catch((e) => (refused = e.message));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is.",
   "keywords": [
     "quo",

package/src/contract/index.ts

@@ -62,7 +62,8 @@ export type Module = { readonly module: string; readonly version: string; readon
 export type Loaded = Module & { readonly from: string };
 
 // Code, by the name a harbor keeps for it, or null where this loader has
-// none. Code never crosses a door and never lives in a cell, so it is the
+// none. Code it has that does not load throws, saying why. Code never
+// 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 abstract class Loader {
   abstract load(from: string): Promise<Loaded | null>;

package/src/harbor/catalogue.ts

@@ -67,10 +67,16 @@ export class Catalogue extends Faculty {
   // it. The rest stay out, each with its reason.
   async wake(): Promise<void> {
     for (const [module, row] of Object.entries(this.#rows)) {
-      const loaded = await this.#harbor.load(row.from).catch(() => null);
+      const loaded = await this.#harbor.load(row.from).catch((e: Error) => e);
       const refused =
-        loaded === null ? `not found at ${row.from}` : loaded.module !== module ? `${row.from} is module ${loaded.module}` : this.#harbor.check([...this.#running.values(), loaded]);
-      if (refused === null) this.#running.set(module, loaded!);
+        loaded instanceof Error
+          ? loaded.message
+          : loaded === null
+            ? `not found at ${row.from}`
+            : loaded.module !== module
+              ? `${row.from} is module ${loaded.module}`
+              : this.#harbor.check([...this.#running.values(), loaded]);
+      if (refused === null) this.#running.set(module, loaded as Loaded);
       else this.#failed.set(module, refused);
     }
     this.#harbor.run([...this.#running.values()]);
@@ -78,7 +84,8 @@ export class Catalogue extends Faculty {
 
   async add(args: JsonObject): Promise<JsonObject> {
     if (!text(args.from)) return { error: 'from is text' };
-    const loaded = await this.#harbor.load(args.from);
+    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' };
     const running = new Map(this.#running);
     running.set(loaded.module, loaded);

package/src/harbor/dock.ts

@@ -158,7 +158,9 @@ export class Dock extends WardBeing implements Lender {
 
   async host(args: JsonObject): Promise<JsonObject> {
     const name = args.ward;
-    if (!text(name) || name === BOX || this.hosted.some((h) => h.ward === name)) return { error: 'no such ward to host' };
+    if (!text(name)) return { error: 'ward is text' };
+    if (name === BOX) return { error: 'box is the box ward' };
+    if (this.hosted.some((h) => h.ward === name)) return { error: `${name} is hosted already` };
     if (args.seed !== undefined && !text(args.seed)) return { error: 'seed is text' };
     const invitation = await this.stance.occupants.invite(name, { hosted: true });
     if (invitation === null) return { error: 'not hosted' };

package/src/node/index.ts

@@ -50,8 +50,10 @@ export const isFile = (from: string): boolean => /^(\.{1,2}[\\/]|[\\/]|[A-Za-z]:
 // Code from a file or an installed package: a module that exports
 // `module`, `version` and `classes`, found again by where it was found, a
 // file by its absolute path and a package by its name, resolved from each
-// folder of `bases` in order. What cannot be imported, or exports no
-// module, is none.
+// folder of `bases` in order. What is not there, or exports no module, is
+// none. Code that is there and does not import throws Node's reason, so
+// whoever added it learns why; an ES module read as CommonJS says which
+// field its package.json lacks.
 export class ImportLoader extends Loader {
   readonly #bases: readonly string[];
   constructor(bases: readonly string[] = [process.cwd()]) {
@@ -65,8 +67,13 @@ export class ImportLoader extends Loader {
     let exported: { module?: unknown; version?: unknown; classes?: unknown };
     try {
       exported = (await import(pathToFileURL(found).href)) as typeof exported;
-    } catch {
-      return null;
+    } catch (e) {
+      const said = (e as Error).message;
+      // The name itself is nowhere, as against code there that needs
+      // something that is not.
+      if ((e as { code?: string }).code === 'ERR_MODULE_NOT_FOUND' && said.includes(`'${found}'`)) return null;
+      const commonjs = e instanceof SyntaxError && /\b(export|import)\b/.test(said);
+      throw new Error(`${found} did not load: ${said}${commonjs ? '; it is an ES module read as CommonJS, so set "type": "module" in its package.json' : ''}`, { cause: e });
     }
     const { module, version, classes } = exported;
     if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes)) return null;

package/src/proof/law.ts

@@ -220,7 +220,7 @@ export const lawScenes = (t: Terrain, expect: Expect): [string, () => Promise<vo
       expect.same(again.names, ['good']);
       expect.same(((await census(again)) as { failed: unknown }).failed, { wards: { bad: 'an entry the package did not seal' }, routes: {} });
       expect.same(await rootLine(again, { ward: 'bad' }), { error: 'the ward did not stand', reason: 'an entry the package did not seal' });
-      expect.same(await again.root('host', { ward: 'bad' }), { error: 'no such ward to host' }, 'its name and seed stay kept');
+      expect.same(await again.root('host', { ward: 'bad' }), { error: 'bad is hosted already' }, 'its name and seed stay kept');
       await spoil(places[1]!);
       let refused = '';
       await world.restart('h', t.again(bodies)).catch((e: Error) => (refused = e.message));