@net-mesh/browser 0.40.0 → 0.41.1

package/dist/peer-driver.js

@@ -58,6 +58,16 @@ export const PEER_TICK_MS = 50;
  * Two anchor hops and one pump, so it is generous rather than tight.
  */
 export const PEER_OFFER_WAIT_MS = 5_000;
+/**
+ * How long an offer that arrived stays worth answering in place of
+ * offering back: the offerer's own ICE deadline (`wasm.rs`'s
+ * `PEER_ICE_DEADLINE_MS`). An older offer's attempt has ended at its
+ * sender, so answering it would only retire this side's own offer for
+ * nothing — and the leaf holds an unanswered offer until something
+ * takes it, so without a bound a stale one would hijack every later
+ * `connectPeer`.
+ */
+export const PEER_OFFER_FRESH_MS = 10_000;
 /**
  * Whether an answer's outcome settles the pair for a `connectPeer` that
  * waited on it, rather than calling for an offer of its own.
@@ -110,10 +120,57 @@ function answerSettles(outcome) {
  *
  * Settled attempts are forgotten: the next call starts fresh. Another
  * tab's node is outside this gate, as it is outside this surface.
+ *
+ * **Between two nodes, the lower id offers (glare).** The gate above
+ * cannot stop the *peer's* offer cancelling this node's: when both
+ * ends call `connectPeer` at once — two pages reaching each other, or
+ * both re-trying after an attempt ended — each answer retires the
+ * answerer's own offer, both run out their ICE deadline, and the pair
+ * stays relayed. So when this node's id is the higher of the pair:
+ *
+ * - its `connectPeer` answers an offer from the peer that arrived
+ *   within {@link PEER_OFFER_FRESH_MS}, instead of offering back;
+ * - while its own offer is under way, an offer arriving from the peer
+ *   is answered, and the answer's outcome is the call's.
+ *
+ * And on either side, an `acceptPeer` while this surface's own
+ * `connectPeer` for the peer is under way takes that call's outcome:
+ * on the lower id the crossing offer is the one to ignore, and on the
+ * higher id the `connectPeer` already answers it.
+ *
+ * Offers are learned from the surface's `signal` events
+ * ({@link noteOffer}); with none noted, or this node's id unknown,
+ * `connectPeer` offers exactly as before.
  */
 export class PeerAttempts {
+    self;
+    now;
     #connecting = new Map();
     #accepting = new Map();
+    /** When an offer from each peer last arrived, by {@link now}. */
+    #offers = new Map();
+    /**
+     * @param self This node's id, 16 hex, or `null` while unknown (no
+     *   tie-break then).
+     * @param now The clock offer arrivals are stamped with.
+     */
+    constructor(self = () => null, now = () => Date.now()) {
+        this.self = self;
+        this.now = now;
+    }
+    /**
+     * A verified offer from `peer` (16 hex) arrived. Arrivals past
+     * {@link PEER_OFFER_FRESH_MS} are dropped here, so the map holds only
+     * peers heard from lately rather than every sender for the node's life.
+     */
+    noteOffer(peer) {
+        const now = this.now();
+        for (const [key, at] of this.#offers) {
+            if (at <= now - PEER_OFFER_FRESH_MS)
+                this.#offers.delete(key);
+        }
+        this.#offers.set(peer.toLowerCase(), now);
+    }
     /**
      * Run `drive` as this peer's offer, unless one is already under way,
      * the pair is already direct, or an answer under way settles it.
@@ -123,8 +180,12 @@ export class PeerAttempts {
      * a round trip, and an `acceptPeer` could take the pair direct and
      * leave the gate between a caller's early reading and its offer, which
      * would then replace the healthy link.
+     *
+     * `answer` answers the offer the peer filed, if one is waiting
+     * (`null` when none is): how the higher id of a pair yields to the
+     * lower id's offer rather than crossing it.
      */
-    connect(peer, healthy, drive) {
+    connect(peer, healthy, drive, answer) {
         const key = peer.toLowerCase();
         const joining = this.#connecting.get(key);
         if (joining !== undefined)
@@ -139,18 +200,81 @@ export class PeerAttempts {
             const dialog = await healthy();
             if (dialog !== undefined && dialog !== null)
                 return { type: 'direct', peer, dialog };
-            return drive();
+            if (answer === undefined || !this.#yields(key))
+                return drive();
+            // The lower id already offered: answer it rather than cross it.
+            if (this.#takeOffer(key, this.now() - PEER_OFFER_FRESH_MS)) {
+                const answered = await answer();
+                // Only an answer that settles the pair stands in for the offer.
+                if (answered !== null && answerSettles(answered))
+                    return answered;
+            }
+            return this.#offerYielding(key, drive, answer);
         })();
         return PeerAttempts.#track(this.#connecting, key, started);
     }
-    /** Run `drive` as this peer's answer, unless one is already under way. */
+    /**
+     * Run `drive` as this peer's answer, unless one is already under way,
+     * or this surface's own `connectPeer` for the peer is (see the class
+     * comment).
+     */
     accept(peer, drive) {
         const key = peer.toLowerCase();
         const joining = this.#accepting.get(key);
         if (joining !== undefined)
             return joining;
+        const connecting = this.#connecting.get(key);
+        if (connecting !== undefined && this.self() !== null)
+            return connecting;
         return PeerAttempts.#track(this.#accepting, key, drive());
     }
+    /** Whether this node is the higher id of the pair, and so answers. */
+    #yields(key) {
+        const self = this.self()?.toLowerCase();
+        // 16 hex each, so the strings order as the ids do.
+        return self !== undefined && self.length === key.length && self > key;
+    }
+    /** Consume a noted offer that arrived after `since`, if there is one. */
+    #takeOffer(key, since) {
+        const at = this.#offers.get(key);
+        if (at === undefined || at <= since)
+            return false;
+        this.#offers.delete(key);
+        return true;
+    }
+    /**
+     * Offer, but answer an offer from the peer that crosses it: this
+     * node is the higher id, so the crossing offer is the one the pair
+     * keeps. The offer's own drive then ends `superseded` by the answer,
+     * and is not the call's outcome.
+     *
+     * The answer, once started, is always awaited: answering retires this
+     * node's offer, so the offer's drive can settle `superseded` while the
+     * answer is still running, and racing the two returned that instead of
+     * the answer's result. With no answer started, the call's outcome is
+     * the offer's, within one tick of its settling.
+     */
+    async #offerYielding(key, drive, answer) {
+        const since = this.now();
+        const offering = drive();
+        let settled = false;
+        const done = () => {
+            settled = true;
+        };
+        offering.then(done, done);
+        const crossed = (async () => {
+            while (!settled) {
+                await tick();
+                if (settled || !this.#takeOffer(key, since))
+                    continue;
+                const answered = await answer();
+                if (answered !== null)
+                    return answered;
+            }
+            return null;
+        })();
+        return crossed.then((answered) => answered ?? offering);
+    }
     static #track(map, key, started) {
         map.set(key, started);
         // Forget it once settled, and only if no newer one took its place.
@@ -162,6 +286,26 @@ export class PeerAttempts {
         return started;
     }
 }
+/**
+ * The `kind` a `signal` event carries for an offer: `SignalKind::tag`
+ * in `control_plane.rs`, which the leaf writes as a bare number.
+ */
+export const SIGNAL_KIND_OFFER = '1';
+/**
+ * Tell `attempts` about an offer, when `event` is a verified one (a
+ * `signal` event of kind {@link SIGNAL_KIND_OFFER}). Every other event
+ * is ignored, as is a sender id that is not an exact decimal u64.
+ */
+export function noteOffer(attempts, event) {
+    if (event.type !== 'signal' || event.kind !== SIGNAL_KIND_OFFER)
+        return;
+    if (event.from === undefined || !/^\d{1,20}$/.test(event.from))
+        return;
+    const id = BigInt(event.from);
+    if (id > 0xffffffffffffffffn)
+        return;
+    attempts.noteOffer(id.toString(16).padStart(16, '0'));
+}
 /** Offer, drive to an open channel, then handshake (§9 steps 3-4). */
 export async function connectPeer(peer, primitives, parse) {
     let dialog;
@@ -210,6 +354,22 @@ export async function acceptPeer(peer, primitives, parse) {
     }
     return driveAttempt(peer, dialog, (status) => status.direct, primitives, parse);
 }
+/**
+ * Answer the offer `peer` filed if one is waiting now, without waiting
+ * for one: `null` when none is, or when the leaf refuses the answer —
+ * the caller ({@link PeerAttempts.connect}, yielding to the lower id)
+ * then offers as it would have.
+ */
+export async function answerWaitingOffer(peer, primitives, parse) {
+    let dialog;
+    try {
+        dialog = await primitives.acceptOffer(peer);
+    }
+    catch {
+        return null;
+    }
+    return driveAttempt(peer, dialog, (status) => status.direct, primitives, parse);
+}
 /**
  * Run the offerer's handshake on an attempt whose channel is open.
  *

package/dist/store/host.d.ts

@@ -115,7 +115,8 @@ export interface StoreTransport {
     connectPeer?(peerHex: string): Promise<unknown>;
 }
 /**
- * A peer id in the spelling `openStream` takes: 16 lowercase hex.
+ * The peer ON AN EVENT, in the spelling `openStream` takes: 16
+ * lowercase hex. For an id the caller holds, see {@link nodeHexOf}.
  *
  * Events carry the authenticated peer as an EXACT DECIMAL string, and
  * `openStream({ peer })` requires 16 hex digits. Handing the decimal
@@ -126,8 +127,23 @@ export interface StoreTransport {
  * reconciliation for the store's own seam.
  */
 export declare function peerHexOf(peer: string): string | null;
-/** Whether two peer spellings name the same node. */
-export declare function samePeer(left: string, right: string): boolean;
+/**
+ * A node id the CALLER holds, in the same spelling: 16 lowercase hex.
+ *
+ * Not {@link peerHexOf}, which reads an event's peer and takes digits
+ * to mean decimal. An id a caller holds is nearly always one this
+ * package printed — `nodeIdHex()`, a descriptor's `peerIdHex`, a
+ * lobby's `host` — and one such id in ~1,800 has no letter in it. Read
+ * as decimal it names a DIFFERENT node: a joiner addressed its host
+ * 4798628394172323 as 00110c53bcd7ffa3, and nothing was there. So
+ * sixteen hex digits are hex, whatever they are made of.
+ *
+ * Any other length is read as {@link peerHexOf} reads it, so an app
+ * may still hand back the decimal `peerNode` an event gave it. A
+ * decimal exactly sixteen digits long is the one spelling that cannot
+ * be told from the canonical hex, and it is read as hex.
+ */
+export declare function nodeHexOf(id: string): string | null;
 /**
  * How a host decides what each replica sees: exactly one of these.
  *

package/dist/store/host.js

@@ -50,7 +50,8 @@ export const HOST_SWEEP_MS = 5_000;
  */
 export const FAREWELL_DEADLINE_MS = 500;
 /**
- * A peer id in the spelling `openStream` takes: 16 lowercase hex.
+ * The peer ON AN EVENT, in the spelling `openStream` takes: 16
+ * lowercase hex. For an id the caller holds, see {@link nodeHexOf}.
  *
  * Events carry the authenticated peer as an EXACT DECIMAL string, and
  * `openStream({ peer })` requires 16 hex digits. Handing the decimal
@@ -74,11 +75,24 @@ export function peerHexOf(peer) {
     }
     return null;
 }
-/** Whether two peer spellings name the same node. */
-export function samePeer(left, right) {
-    const a = peerHexOf(left);
-    const b = peerHexOf(right);
-    return a !== null && a === b;
+/**
+ * A node id the CALLER holds, in the same spelling: 16 lowercase hex.
+ *
+ * Not {@link peerHexOf}, which reads an event's peer and takes digits
+ * to mean decimal. An id a caller holds is nearly always one this
+ * package printed — `nodeIdHex()`, a descriptor's `peerIdHex`, a
+ * lobby's `host` — and one such id in ~1,800 has no letter in it. Read
+ * as decimal it names a DIFFERENT node: a joiner addressed its host
+ * 4798628394172323 as 00110c53bcd7ffa3, and nothing was there. So
+ * sixteen hex digits are hex, whatever they are made of.
+ *
+ * Any other length is read as {@link peerHexOf} reads it, so an app
+ * may still hand back the decimal `peerNode` an event gave it. A
+ * decimal exactly sixteen digits long is the one spelling that cannot
+ * be told from the canonical hex, and it is read as hex.
+ */
+export function nodeHexOf(id) {
+    return /^[0-9a-f]{16}$/i.test(id) ? id.toLowerCase() : peerHexOf(id);
 }
 /**
  * The store addresses live on each transport.
@@ -663,7 +677,7 @@ export function hostStore(options) {
         owner: owner,
         // The spelling `AccessRequest.peer` and `ActionContext.peer`
         // promise: 16 lowercase hex, as a replica's frames are handed.
-        peer: peerHexOf(authority) ?? authority,
+        peer: nodeHexOf(authority) ?? authority,
         maxEventBytes: options.maxEventBytes,
         dispatched,
         isClosed: () => closed,

package/dist/store/index.d.ts

@@ -48,3 +48,26 @@ export type { Hidden, Visibility, VisibilityPreset, VisibilityRule, VisibilityRu
 export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
 export type { CellOptions } from './interest.js';
 export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';
+export { Assembly, ASSEMBLY_DEADLINE_MS, AssemblyTable, MAX_ASSEMBLY_BYTES_TOTAL, } from './assembly.js';
+export type { AssemblyChunk, AssemblyManifest, AssemblyRefusal, AssemblyRejected, ChunkOutcome, } from './assembly.js';
+export { assertChunkingFits, base64, chunkBytesFor, chunkSnapshot, fromBase64, jsonByteLength, LARGEST_FROZEN_ENVELOPE, MIN_CHUNK_BYTES, SNAP_ENVELOPE_RESERVE, } from './chunker.js';
+export type { Chunked, } from './chunker.js';
+export { isEntityMap, } from './definition.js';
+export { isStaleStream, STORE_ERROR_CODES, } from './errors.js';
+export { FAREWELL_DEADLINE_MS, hostInternals, nodeHexOf, peerHexOf, } from './host.js';
+export type { HostInternals, } from './host.js';
+export { TICK_INTERVAL_MS, TRANSITION_DEADLINE_MS, } from './join.js';
+export { MAX_JSON_DEPTH, parseStoreJson, } from './json.js';
+export type { JsonFailure, JsonObject, JsonRefusal, JsonResult, JsonValue, } from './json.js';
+export { BINDING_INLINE_MAX_BYTES, canonicalBytes, canonicalRequest, digestBinding, HandleLedger, inlineBinding, InputSequences, LEDGER_MAX_AGE_MS, LEDGER_MAX_BYTES, LEDGER_MAX_ENTRIES, LedgerTable, MAX_SEQUENCE, needsDigest, } from './ledger.js';
+export type { Disposition, Outcome, RequestBinding, } from './ledger.js';
+export { HANDLE_LEASE_MS, MAX_HANDLES, MAX_PENDING_ACTIONS, StoreOwner, } from './owner.js';
+export type { ActionHandlers, Dispatched, InputHandlers, Outbound, OwnerDeps, OwnerHandle, } from './owner.js';
+export { applyPatch, FORBIDDEN_SEGMENTS, } from './patch.js';
+export type { PatchApplied, PatchOutcome, PatchRefusal, PatchRejected, } from './patch.js';
+export { MAX_JOIN_REASKS, StoreReplica, } from './replica.js';
+export type { Received, ReplicaDeps, ReplicaState, Request, } from './replica.js';
+export { applyVisibility, compileVisibility, } from './visibility.js';
+export type { CompiledVisibility, } from './visibility.js';
+export { CALLER_KINDS, decimalValue, decodeMessage, encodeMessage, HANDLE_HEX_LENGTH, inadmissibleValue, INCARNATION_HEX_LENGTH, isCanonicalBase64, isCanonicalDecimal, isCanonicalHex, MAX_AUDIENCE_LABEL_BYTES, MAX_AUDIENCE_LABELS, MAX_DECIMAL, MAX_DETAIL_BYTES, MAX_PATCH_OPS, MAX_PATH_SEGMENT_BYTES, MAX_PATH_SEGMENTS, MAX_SNAPSHOT_BYTES, MAX_SNAPSHOT_CHUNKS, OWNER_KINDS, REQUEST_HEX_LENGTH, utf8Length, WIRE_VERSION, } from './wire.js';
+export type { ActMessage, AliveMessage, AudienceMessage, CallerKind, CallerMessage, Decimal, DecodeOptions, DecodeRefusal, DecodeResult, DecodeStage, DeltaMessage, Hex, InputMessage, InterestMessage, JoinMessage, LeaveMessage, ManifestMessage, MessageFor, MessageKind, NoMessage, OkMessage, OwnerKind, OwnerMessage, ResultMessage, ResumeMessage, ResyncMessage, Side, SnapMessage, StoreMessage, WireOp, } from './wire.js';

package/dist/store/index.js

@@ -38,3 +38,19 @@ export { addItems, countItems, emptyInventory, hasItems, InventoryError, invento
 export { assertHidden, HIDDEN, hiddenOr, isHidden, projectVisible, } from './visibility.js';
 export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
 export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';
+// The store's lower-level building blocks — wire codec, ledgers,
+// chunking, owner/replica cores — exported so callers can compose
+// their own transports and tooling.
+export { Assembly, ASSEMBLY_DEADLINE_MS, AssemblyTable, MAX_ASSEMBLY_BYTES_TOTAL, } from './assembly.js';
+export { assertChunkingFits, base64, chunkBytesFor, chunkSnapshot, fromBase64, jsonByteLength, LARGEST_FROZEN_ENVELOPE, MIN_CHUNK_BYTES, SNAP_ENVELOPE_RESERVE, } from './chunker.js';
+export { isEntityMap, } from './definition.js';
+export { isStaleStream, STORE_ERROR_CODES, } from './errors.js';
+export { FAREWELL_DEADLINE_MS, hostInternals, nodeHexOf, peerHexOf, } from './host.js';
+export { TICK_INTERVAL_MS, TRANSITION_DEADLINE_MS, } from './join.js';
+export { MAX_JSON_DEPTH, parseStoreJson, } from './json.js';
+export { BINDING_INLINE_MAX_BYTES, canonicalBytes, canonicalRequest, digestBinding, HandleLedger, inlineBinding, InputSequences, LEDGER_MAX_AGE_MS, LEDGER_MAX_BYTES, LEDGER_MAX_ENTRIES, LedgerTable, MAX_SEQUENCE, needsDigest, } from './ledger.js';
+export { HANDLE_LEASE_MS, MAX_HANDLES, MAX_PENDING_ACTIONS, StoreOwner, } from './owner.js';
+export { applyPatch, FORBIDDEN_SEGMENTS, } from './patch.js';
+export { MAX_JOIN_REASKS, StoreReplica, } from './replica.js';
+export { applyVisibility, compileVisibility, } from './visibility.js';
+export { CALLER_KINDS, decimalValue, decodeMessage, encodeMessage, HANDLE_HEX_LENGTH, inadmissibleValue, INCARNATION_HEX_LENGTH, isCanonicalBase64, isCanonicalDecimal, isCanonicalHex, MAX_AUDIENCE_LABEL_BYTES, MAX_AUDIENCE_LABELS, MAX_DECIMAL, MAX_DETAIL_BYTES, MAX_PATCH_OPS, MAX_PATH_SEGMENT_BYTES, MAX_PATH_SEGMENTS, MAX_SNAPSHOT_BYTES, MAX_SNAPSHOT_CHUNKS, OWNER_KINDS, REQUEST_HEX_LENGTH, utf8Length, WIRE_VERSION, } from './wire.js';

package/dist/store/join.d.ts

@@ -57,7 +57,12 @@ export declare const MAX_OUTSTANDING = 64;
 export interface JoinStoreOptions<S extends object, A extends ActionSpec, I extends InputSpec> {
     readonly definition: StoreDefinition<S, A, I>;
     readonly transport: StoreTransport;
-    /** The node hosting the store. */
+    /**
+     * The node hosting the store: 16 hex digits, as `nodeIdHex()` and a
+     * descriptor's `peerIdHex` print it. The decimal `peerNode` of an
+     * event is accepted too, unless it is exactly sixteen digits long —
+     * that is the hex spelling, and it is read as hex.
+     */
     readonly host: string;
     /** The audience this caller wants. */
     readonly audience: readonly string[];

package/dist/store/join.js

@@ -23,7 +23,7 @@
  */
 import { StoreCore } from './core.js';
 import { isStaleStream, StoreError } from './errors.js';
-import { peerHexOf, samePeer } from './host.js';
+import { nodeHexOf, peerHexOf } from './host.js';
 import { StoreReplica } from './replica.js';
 import { decodeMessage, encodeMessage, utf8Length } from './wire.js';
 /** How often a live handle renews its lease (§1.6). */
@@ -83,7 +83,10 @@ export function joinStore(options) {
     // had already accepted the subscription. Refused here instead,
     // where the caller can read what it did wrong.
     const selfId = options.transport.nodeIdHex();
-    if (selfId !== null && samePeer(selfId, options.host)) {
+    // Read ONCE, as an id the caller holds: hex when it is the sixteen
+    // digits `nodeIdHex()` prints, even when none of them is a letter.
+    const hostHex = nodeHexOf(options.host);
+    if (selfId !== null && hostHex !== null && nodeHexOf(selfId) === hostHex) {
         throw new StoreError('invalid-data', 'a replica cannot join the node it runs on: hold the hostStore handle instead');
     }
     const streamId = options.streamId ?? `store/${options.definition.id}`;
@@ -124,8 +127,7 @@ export function joinStore(options) {
             return upstream;
         if (opening !== null)
             return opening;
-        const addressable = peerHexOf(options.host);
-        if (addressable === null) {
+        if (hostHex === null) {
             return Promise.reject(new StoreError('invalid-data', `the host id is not a node id: ${options.host}`));
         }
         // `label`, never `streamId`: see {@link StoreTransport.openStream}.
@@ -139,11 +141,11 @@ export function joinStore(options) {
         // the relay is installed before the direct half is even tried, so
         // the open below is the thing that decides, and its refusal is
         // typed.
-        opening = Promise.resolve(options.transport.connectPeer?.(addressable))
+        opening = Promise.resolve(options.transport.connectPeer?.(hostHex))
             .catch(() => undefined)
             .then(() => options.transport.openStream({
             reliability: 'reliable',
-            peer: addressable,
+            peer: hostHex,
             label: streamId,
         }))
             .then(open => {
@@ -350,8 +352,12 @@ export function joinStore(options) {
         // is what identifies this store's traffic.
         // The host's identity, compared as a NUMBER: the event carries an
         // exact decimal and `options.host` is hex, so `!==` on the strings
-        // rejected every frame the host ever sent.
-        if (typeof event.peerNode !== 'string' || !samePeer(event.peerNode, options.host))
+        // rejected every frame the host ever sent. Each side is read in
+        // its OWN spelling: one reader for both took an all-digit hex host
+        // for a decimal, and then no frame of that host's ever matched.
+        if (typeof event.peerNode !== 'string' || hostHex === null)
+            return;
+        if (peerHexOf(event.peerNode) !== hostHex)
             return;
         const payload = event.payload;
         if (payload === undefined)

package/dist/world/link.js

@@ -14,7 +14,7 @@
  * handoffs.handoff('ship-7', 'r:4:8');         // when the ship crosses the border
  * ```
  */
-import { peerHexOf } from '../store/host.js';
+import { nodeHexOf, peerHexOf } from '../store/host.js';
 import { ghostTargets, onForwardedAction, pruneActs, } from './border.js';
 import { beginHandoff, locate, onHandoffOffer, onHandoffReply, pruneHandled, reofferHandoff, retryHandoffs, } from './handoff.js';
 const encoder = new TextEncoder();
@@ -140,7 +140,7 @@ export function handoffLink(options) {
         // handoff on another region's behalf.
         const sender = typeof event.peerNode === 'string' ? peerHexOf(event.peerNode) : null;
         const expected = options.peerOf(body.from);
-        if (sender === null || expected === null || peerHexOf(expected) !== sender) {
+        if (sender === null || expected === null || nodeHexOf(expected) !== sender) {
             drop('unauthenticated');
             refresh(body.from);
             return;
@@ -153,7 +153,7 @@ export function handoffLink(options) {
             if (closed)
                 return;
             const peer = options.peerOf(message.to);
-            const hex = peer === null ? null : peerHexOf(peer);
+            const hex = peer === null ? null : nodeHexOf(peer);
             if (hex === null) {
                 drop('unknown-region');
                 refresh(message.to);

package/dist/world/regions.js

@@ -27,7 +27,7 @@
  * directory (`handoffLink({ peerOf: directory.peerOf })`) needs the list:
  * otherwise a node that announces a region could also send offers as it.
  */
-import { peerHexOf } from '../store/host.js';
+import { nodeHexOf } from '../store/host.js';
 import { joinStore } from '../store/join.js';
 /** Region `r:<rx>:<rz>` for a position, with regions `size` units square. */
 export function regionOf(x, z, size) {
@@ -77,7 +77,7 @@ export function announceRegions(node, world, regions, options = {}) {
 export function regionDirectory(options) {
     const trusted = options.trustedHosts === undefined
         ? null
-        : new Set(options.trustedHosts.map(id => peerHexOf(id)).filter((id) => id !== null));
+        : new Set(options.trustedHosts.map(id => nodeHexOf(id)).filter((id) => id !== null));
     const cache = new Map();
     return {
         async lookup(region) {
@@ -90,7 +90,7 @@ export function regionDirectory(options) {
             }
             const hosts = [
                 ...new Set(found
-                    .map(descriptor => peerHexOf(descriptor.peerIdHex))
+                    .map(descriptor => nodeHexOf(descriptor.peerIdHex))
                     .filter((id) => id !== null && (trusted === null || trusted.has(id)))),
             ].sort();
             const answer = hosts.length === 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@net-mesh/browser",
-  "version": "0.40.0",
+  "version": "0.41.1",
   "description": "Browser-native Net mesh leaf \u2014 idiomatic TypeScript over the net-mesh-leaf wasm node",
   "type": "module",
   "main": "dist/index.js",