nervur 0.22.0 → 0.22.1

package/dist/core/harbor/carrying.d.ts

@@ -37,8 +37,7 @@ export declare abstract class CarrierFaculty extends Faculty {
     abstract accepts(address: string): boolean;
     abstract dial(address: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
     listening(): string[];
-    relays(_pk: string): boolean;
-    relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null>;
+    relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null> | null;
     heard(): Promise<void>;
     awake(): Promise<void>;
     sleep(): Promise<void>;

package/dist/core/harbor/carrying.js

@@ -34,13 +34,10 @@ export class CarrierFaculty extends Faculty {
     listening() {
         return [];
     }
-    // Whether it answers for a ward pk no door of this harbor holds, as a
-    // relay does, and its answer.
-    relays(_pk) {
-        return false;
-    }
+    // Its answer to a box for a ward pk no door of this harbor holds, where
+    // it answers for that pk, as a relay does, and null where it does not.
     relay(_pk, _bytes) {
-        return Promise.resolve(null);
+        return null;
     }
     // A push the device heard, which says only that something waits: a
     // carrier that collects for this harbor collects now.

package/dist/core/harbor/harbor.js

@@ -212,7 +212,7 @@ export class Harbor {
         const ward = this.#door(pk);
         if (ward)
             return (await ward.door.arrive(bytes)).bytes;
-        return (await this.#relaying(pk)?.relay(pk, bytes)) ?? null;
+        return (await this.#relayed(pk, bytes)) ?? null;
     }
     // Whether one of this harbor's doors is that ward's.
     holds(pk) {
@@ -345,8 +345,11 @@ export class Harbor {
     // order, each to the carrier that dials it, and with no route the
     // terrain's carrier.
     async #carry(pk, bytes) {
-        if (this.holds(pk) || this.#relaying(pk))
+        if (this.holds(pk))
             return this.arrive(pk, bytes);
+        const relayed = this.#relayed(pk, bytes);
+        if (relayed !== undefined)
+            return relayed;
         const at = this.#dock.routes[pk];
         if (at === undefined)
             return this.#terrain.carrier.carry(pk, bytes);
@@ -396,8 +399,15 @@ export class Harbor {
             .map((key) => this.#box.being(key))
             .filter((being) => being instanceof CarrierFaculty);
     }
-    #relaying(pk) {
-        return this.#carriers.find((carrier) => carrier.relays(pk));
+    // The answer of the first carrier that answers for a pk no door holds,
+    // or undefined where none does.
+    #relayed(pk, bytes) {
+        for (const carrier of this.#carriers) {
+            const out = carrier.relay(pk, bytes);
+            if (out !== null)
+                return out;
+        }
+        return undefined;
     }
     #dialable(at) {
         return at.some((address) => this.#carriers.some((carrier) => carrier.accepts(address)));

package/dist/core/ward/house.d.ts

@@ -56,6 +56,9 @@ export declare class House implements Behind, Inside {
     root(method?: string, args?: JsonObject): Promise<Answer>;
     get zero(): boolean;
     answer(heir: string | null, p: Payload): Promise<Choice>;
+    within(heir: string, take: boolean, method?: string, args?: string): Promise<Choice | {
+        readonly quo: 'removed';
+    }>;
     send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
     offer(contract: string): Promise<Invitation | null>;
     retract(contract: string, heir: string): Promise<void>;

package/dist/core/ward/house.js

@@ -223,17 +223,44 @@ export class House {
         const row = key === WARD || this.#parts.stands ? undefined : this.partition.being(key);
         return row !== undefined && this.#classOf(row) !== undefined;
     }
-    async answer(heir, p) {
+    answer(heir, p) {
+        return this.#choose(heir, p.method, p.args);
+    }
+    // An ask on a relation between two beings of this ward, with no seal:
+    // both ends are this house's, so a seal would prove nothing to it. A take
+    // binds a fresh heir here and takes it from the door, so no box ever
+    // speaks under it again; an ask speaks while the heir stays bound here,
+    // and hears `removed` once its occupant is gone. A take that brings no
+    // object leaves the heir fresh on the door, as it was.
+    async within(heir, take, method, args) {
+        const { bind } = this.partition.head;
+        const bound = Object.hasOwn(bind, heir) ? bind[heir] : undefined;
+        if (!take)
+            return bound?.inside ? this.#choose(heir, method, args) : { quo: 'removed' };
+        if (!bound || bound.inside || this.door.relations.get(heir)?.state !== 'fresh')
+            return { silence: true };
+        const inside = { ...bound, inside: true };
+        this.door.relations.delete(heir);
+        bind[heir] = inside;
+        this.partition.toldHead();
+        const choice = await this.#choose(heir, method, args);
+        if ('object' in choice || bind[heir] !== inside)
+            return choice;
+        bind[heir] = bound;
+        this.door.relations.set(heir, { state: 'fresh' });
+        return choice;
+    }
+    async #choose(heir, method, text) {
         const bound = heir === null ? undefined : this.partition.head.bind[heir];
         const key = heir === null ? this.partition.head.public : bound?.being;
         const asker = bound ? { id: bound.id } : {};
-        const args = p.args === undefined ? {} : readValue(p.args, DEPTH + 1);
+        const args = text === undefined ? {} : readValue(text, DEPTH + 1);
         if (key === null || key === undefined || typeof args !== 'object' || args === null || Array.isArray(args))
             return { silence: true };
         let seen = null;
         const out = await this.#kept([key], () => this.#with(key, silence, async (being) => {
-            const reply = await this.#reply(being, asker, p.method, args);
-            if (p.method !== undefined && !isSilence(reply) && !isWord(reply) && being.describe)
+            const reply = await this.#reply(being, asker, method, args);
+            if (method !== undefined && !isSilence(reply) && !isWord(reply) && being.describe)
                 seen = await digest(being.describe(asker));
             return reply;
         }));
@@ -306,10 +333,9 @@ export class House {
         return row ? new HouseStance(this, key, row, this.#parts.carries ?? {}) : undefined;
     }
     // Inside: what every stance of this ward stands on.
-    // One path through a door for every ask, this ward's own included.
-    async send(pk, bytes) {
-        if (pk === this.pk)
-            return (await this.door.arrive(bytes)).bytes;
+    // A box to another ward's door, wherever it stands; this ward's own
+    // relations speak `within`.
+    send(pk, bytes) {
         return this.#parts.carrier.carry(pk, bytes);
     }
     // A lend: the ward lends herself, as the dock does, or asks the dock

package/dist/core/ward/partition.d.ts

@@ -10,6 +10,7 @@ export type Head = {
     bind: Record<string, {
         being: string;
         id: string;
+        inside?: true;
     }>;
     public: string | null;
 };

package/dist/core/ward/stance.d.ts

@@ -1,4 +1,4 @@
-import { type Door, type Draw, type Invitation } from '../quo/index.ts';
+import { type Door, type Draw, type Invitation, type Read } from '../quo/index.ts';
 import type { Clock } from '../contract/index.ts';
 import { type JsonObject, type Occupants, type Stance, type Standings } from '../being/index.ts';
 import type { BeingRow, Partition } from './partition.ts';
@@ -9,8 +9,10 @@ export interface Inside {
     readonly door: Door;
     readonly draw: Draw;
     readonly clock: Clock;
+    readonly pk: string;
     live(key: string, row: BeingRow): boolean;
     send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    within(heir: string, take: boolean, method?: string, args?: string): Promise<Read>;
     boot(maker: string, className: string, key: string, id?: string): Promise<string | null>;
     offer(contract: string): Promise<Invitation | null>;
     retract(contract: string, heir: string): Promise<void>;

package/dist/core/ward/stance.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // One being's stance: her cells, the ids she invited, the relations she
-// holds, and boot. Every relation she holds speaks through `quo/`'s
-// standing, one send at a time, inside her allowance.
+// holds, and boot. A relation on another ward speaks through `quo/`'s
+// standing, one on her own ward straight to her ward, each one send at a
+// time, inside her allowance.
 import { readValue, writeValue } from '../crypto/index.js';
 import { readInvitation, Standing as Wire, freshStanding } from '../quo/index.js';
 import { OWNER, ownKind, silence, word } from '../being/index.js';
@@ -120,6 +121,8 @@ export class HouseStance {
             await this.#inside.learn(invitation.ward, invitation.at);
         const wire = new Wire(invitation, freshStanding(), this.#inside.draw);
         const read = await this.#lanes.run(`take:${id}`, async () => {
+            if (invitation.ward === this.#inside.pk)
+                return this.#inside.within(invitation.heir, true);
             // A knock that brought nothing back may have bound: the standing asks
             // under its own key, then knocks again as the same bytes.
             let out = await this.#send(wire);
@@ -157,9 +160,13 @@ export class HouseStance {
                     return word('dropped');
                 if (bell.rang)
                     return word('late');
-                const wire = new Wire(row.invitation, row.state, this.#inside.draw);
-                const read = await bell.race(this.#send(wire, method, text));
-                row.state = wire.state;
+                // A relation inside this ward speaks with no seal, any other
+                // through the far ward's door.
+                const inside = row.invitation.ward === this.#inside.pk;
+                const wire = inside ? null : new Wire(row.invitation, row.state, this.#inside.draw);
+                const read = await bell.race(wire ? this.#send(wire, method, text) : this.#inside.within(row.invitation.heir, false, method, text));
+                if (wire)
+                    row.state = wire.state;
                 if (read === LATE)
                     return word('late');
                 if ('object' in read)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is.",
   "keywords": [
     "quo",
@@ -8,9 +8,16 @@
     "capability",
     "object-capability"
   ],
-  "author": "Razvan Gherghina",
+  "author": "Bookarest Digital SRL",
   "license": "Apache-2.0",
   "homepage": "https://nervur.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nervur-org/nervur.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nervur-org/nervur/issues"
+  },
   "type": "module",
   "bin": {
     "nervur": "dist/cli.js"
@@ -58,8 +65,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && node kit.mjs",
-    "check": "tsc -p tsconfig.json && npm run build &&node ../../test.mjs \"test/core/**/*.test.ts\" \"test/defaults/**/*.test.ts\" \"test/kit/*.test.ts\"",
-    "deep": "node ../../test.mjs \"test/terrain/*.test.ts\"",
+    "check": "tsc -p tsconfig.json && npm run build &&node test.mjs \"test/core/**/*.test.ts\" \"test/defaults/**/*.test.ts\" \"test/kit/*.test.ts\"",
+    "deep": "node test.mjs \"test/terrain/*.test.ts\"",
     "cover": "node test/cover.mjs",
     "mutate": "node test/mutate.mjs",
     "prepublishOnly": "test \"$NERVUR_GATED\" = 1 || { echo 'a publish is /release, from the root, on the human'\"'\"'s word' >&2; exit 1; }"
@@ -82,6 +89,17 @@
     "NOTICE"
   ],
   "devDependencies": {
+    "@stryker-mutator/core": "^10.0.0",
+    "@stryker-mutator/instrumenter": "^10.0.0",
+    "@types/node": "^26.4.1",
+    "bun": "^1.4.0",
+    "deno": "^2.9.6",
+    "esbuild": "^0.28.2",
+    "istanbul-lib-coverage": "^3.2.2",
+    "playwright": "^1.62.1",
+    "typescript": "^7.0.2",
+    "v8-to-istanbul": "^9.3.0",
+    "workerd": "^1.20260904.1",
     "wrangler": "^4.134.0"
   }
 }

package/src/core/harbor/carrying.ts

@@ -87,13 +87,10 @@ export abstract class CarrierFaculty extends Faculty {
     return [];
   }
 
-  // Whether it answers for a ward pk no door of this harbor holds, as a
-  // relay does, and its answer.
-  relays(_pk: string): boolean {
-    return false;
-  }
-  relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null> {
-    return Promise.resolve(null);
+  // Its answer to a box for a ward pk no door of this harbor holds, where
+  // it answers for that pk, as a relay does, and null where it does not.
+  relay(_pk: string, _bytes: Uint8Array): Promise<Uint8Array | null> | null {
+    return null;
   }
 
   // A push the device heard, which says only that something waits: a

package/src/core/harbor/harbor.ts

@@ -209,7 +209,7 @@ export class Harbor {
   async arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
     const ward = this.#door(pk);
     if (ward) return (await ward.door.arrive(bytes)).bytes;
-    return (await this.#relaying(pk)?.relay(pk, bytes)) ?? null;
+    return (await this.#relayed(pk, bytes)) ?? null;
   }
 
   // Whether one of this harbor's doors is that ward's.
@@ -342,7 +342,9 @@ export class Harbor {
   // order, each to the carrier that dials it, and with no route the
   // terrain's carrier.
   async #carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    if (this.holds(pk) || this.#relaying(pk)) return this.arrive(pk, bytes);
+    if (this.holds(pk)) return this.arrive(pk, bytes);
+    const relayed = this.#relayed(pk, bytes);
+    if (relayed !== undefined) return relayed;
     const at = this.#dock.routes[pk];
     if (at === undefined) return this.#terrain.carrier.carry(pk, bytes);
     for (const address of at) {
@@ -390,8 +392,14 @@ export class Harbor {
       .filter((being): being is CarrierFaculty => being instanceof CarrierFaculty);
   }
 
-  #relaying(pk: string): CarrierFaculty | undefined {
-    return this.#carriers.find((carrier) => carrier.relays(pk));
+  // The answer of the first carrier that answers for a pk no door holds,
+  // or undefined where none does.
+  #relayed(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> | undefined {
+    for (const carrier of this.#carriers) {
+      const out = carrier.relay(pk, bytes);
+      if (out !== null) return out;
+    }
+    return undefined;
   }
 
   #dialable(at: readonly string[]): boolean {

package/src/core/ward/house.ts

@@ -284,17 +284,43 @@ export class House implements Behind, Inside {
     return row !== undefined && this.#classOf(row) !== undefined;
   }
 
-  async answer(heir: string | null, p: Payload): Promise<Choice> {
+  answer(heir: string | null, p: Payload): Promise<Choice> {
+    return this.#choose(heir, p.method, p.args);
+  }
+
+  // An ask on a relation between two beings of this ward, with no seal:
+  // both ends are this house's, so a seal would prove nothing to it. A take
+  // binds a fresh heir here and takes it from the door, so no box ever
+  // speaks under it again; an ask speaks while the heir stays bound here,
+  // and hears `removed` once its occupant is gone. A take that brings no
+  // object leaves the heir fresh on the door, as it was.
+  async within(heir: string, take: boolean, method?: string, args?: string): Promise<Choice | { readonly quo: 'removed' }> {
+    const { bind } = this.partition.head;
+    const bound = Object.hasOwn(bind, heir) ? bind[heir]! : undefined;
+    if (!take) return bound?.inside ? this.#choose(heir, method, args) : { quo: 'removed' };
+    if (!bound || bound.inside || this.door.relations.get(heir)?.state !== 'fresh') return { silence: true };
+    const inside = { ...bound, inside: true as const };
+    this.door.relations.delete(heir);
+    bind[heir] = inside;
+    this.partition.toldHead();
+    const choice = await this.#choose(heir, method, args);
+    if ('object' in choice || bind[heir] !== inside) return choice;
+    bind[heir] = bound;
+    this.door.relations.set(heir, { state: 'fresh' });
+    return choice;
+  }
+
+  async #choose(heir: string | null, method: string | undefined, text: string | undefined): Promise<Choice> {
     const bound = heir === null ? undefined : this.partition.head.bind[heir];
     const key = heir === null ? this.partition.head.public : bound?.being;
     const asker: Asker = bound ? { id: bound.id } : {};
-    const args = p.args === undefined ? {} : readValue(p.args, DEPTH + 1);
+    const args = text === undefined ? {} : readValue(text, DEPTH + 1);
     if (key === null || key === undefined || typeof args !== 'object' || args === null || Array.isArray(args)) return { silence: true };
     let seen: string | null = null;
     const out = await this.#kept([key], () =>
       this.#with(key, silence, async (being) => {
-        const reply = await this.#reply(being, asker, p.method, args);
-        if (p.method !== undefined && !isSilence(reply) && !isWord(reply) && being.describe) seen = await digest(being.describe(asker));
+        const reply = await this.#reply(being, asker, method, args);
+        if (method !== undefined && !isSilence(reply) && !isWord(reply) && being.describe) seen = await digest(being.describe(asker));
         return reply;
       }),
     );
@@ -366,9 +392,9 @@ export class House implements Behind, Inside {
 
   // Inside: what every stance of this ward stands on.
 
-  // One path through a door for every ask, this ward's own included.
-  async send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
-    if (pk === this.pk) return (await this.door.arrive(bytes)).bytes;
+  // A box to another ward's door, wherever it stands; this ward's own
+  // relations speak `within`.
+  send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null> {
     return this.#parts.carrier.carry(pk, bytes);
   }
 

package/src/core/ward/partition.ts

@@ -3,7 +3,8 @@
 // its terrain opened for it.
 //
 //   rows.ward           the door's lock, heirs and gone, which being and id
-//                       each heir belongs to, and the public being
+//                       each heir belongs to and whether a being of this
+//                       ward took it, and the public being
 //   rows.beings[key]    one being: her class and the registry it resolves
 //                       through, cells, occupants and standings
 //
@@ -21,7 +22,9 @@ export type Head = {
   lock?: KeptLock;
   heirs: Record<string, HeirRecord>;
   gone: string[];
-  bind: Record<string, { being: string; id: string }>;
+  // `inside` where a being of this ward took the heir: its relation lives
+  // here alone and no door holds it.
+  bind: Record<string, { being: string; id: string; inside?: true }>;
   public: string | null;
 };
 

package/src/core/ward/stance.ts

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // One being's stance: her cells, the ids she invited, the relations she
-// holds, and boot. Every relation she holds speaks through `quo/`'s
-// standing, one send at a time, inside her allowance.
+// holds, and boot. A relation on another ward speaks through `quo/`'s
+// standing, one on her own ward straight to her ward, each one send at a
+// time, inside her allowance.
 import { readValue, writeValue } from '../crypto/index.ts';
 import { readInvitation, Standing as Wire, freshStanding, type Door, type Draw, type Invitation, type Read } from '../quo/index.ts';
 import type { Clock } from '../contract/index.ts';
@@ -18,8 +19,11 @@ export interface Inside {
   readonly door: Door;
   readonly draw: Draw;
   readonly clock: Clock;
+  readonly pk: string;
   live(key: string, row: BeingRow): boolean;
   send(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+  // A relation whose both ends are this ward's, taken or asked with no seal.
+  within(heir: string, take: boolean, method?: string, args?: string): Promise<Read>;
   boot(maker: string, className: string, key: string, id?: string): Promise<string | null>;
   // An offer from the faculty the dock opened for a contract, and its
   // retraction when the offer was not taken.
@@ -145,6 +149,7 @@ export class HouseStance implements Stance {
     if (invitation.at) await this.#inside.learn(invitation.ward, invitation.at);
     const wire = new Wire(invitation, freshStanding(), this.#inside.draw);
     const read = await this.#lanes.run(`take:${id}`, async () => {
+      if (invitation.ward === this.#inside.pk) return this.#inside.within(invitation.heir, true);
       // A knock that brought nothing back may have bound: the standing asks
       // under its own key, then knocks again as the same bytes.
       let out = await this.#send(wire);
@@ -179,9 +184,12 @@ export class HouseStance implements Stance {
           const row = Object.hasOwn(this.#row.standings, id) ? this.#row.standings[id] : undefined;
           if (!this.#live || row === undefined) return word('dropped');
           if (bell.rang) return word('late');
-          const wire = new Wire(row.invitation, row.state, this.#inside.draw);
-          const read = await bell.race(this.#send(wire, method as string | undefined, text));
-          row.state = wire.state;
+          // A relation inside this ward speaks with no seal, any other
+          // through the far ward's door.
+          const inside = row.invitation.ward === this.#inside.pk;
+          const wire = inside ? null : new Wire(row.invitation, row.state, this.#inside.draw);
+          const read = await bell.race(wire ? this.#send(wire, method as string | undefined, text) : this.#inside.within(row.invitation.heir, false, method as string | undefined, text));
+          if (wire) row.state = wire.state;
           if (read === LATE) return word('late');
           if ('object' in read) row.seen = read.seen;
           this.#told();