tesseract-agent 0.11.0 → 0.11.1

package/dist-bundle/cli.js

@@ -109820,6 +109820,36 @@ async function getPeerIdentityPub(opts) {
 import { createSocket as createSocket2 } from "node:dgram";
 import { createRequire as createRequire4 } from "node:module";
 
+// ../../packages/host-core/dist/mesh/bundle-gossip.js
+var BundleOfferLedger = class {
+  #offered = /* @__PURE__ */ new Set();
+  /**
+   * Should we offer epoch `mine` to this peer, and record that we did?
+   *
+   * Returns false when we are not ahead (including equal — an offer would tell them
+   * nothing), and false for a peer already offered THIS epoch. Keyed by epoch as well as
+   * peer, so a newer bundle is offered afresh to someone we have already talked to.
+   */
+  claim(peerHex, peerEpoch, mine) {
+    if (!(mine > peerEpoch))
+      return false;
+    const key2 = `${peerHex}:${mine}`;
+    if (this.#offered.has(key2))
+      return false;
+    this.#offered.add(key2);
+    return true;
+  }
+  /**
+   * Forget everything, because we just adopted a newer bundle and are now the node that is
+   * ahead. Without this the ledger would still be keyed to the epoch we no longer hold —
+   * harmless for correctness (the key carries the epoch) but it would grow without bound on
+   * a long-lived node, one entry per peer per epoch forever.
+   */
+  reset() {
+    this.#offered.clear();
+  }
+};
+
 // ../../packages/host-core/dist/mesh/config.js
 init_credentials();
 import { chmodSync as chmodSync5, existsSync as existsSync33, mkdirSync as mkdirSync36, readdirSync as readdirSync12, readFileSync as readFileSync47, renameSync as renameSync11, rmSync as rmSync7, writeFileSync as writeFileSync35 } from "node:fs";
@@ -110289,6 +110319,12 @@ var MeshNode = class {
   #timer = null;
   #unsubscribe = null;
   #identity = null;
+  /** The policy bundle we hold, as bytes, so we can OFFER it to a peer that is behind.
+   *  Kept beside the engine because the engine exposes an epoch but not the bytes. */
+  #bundle = null;
+  /** Who has already been offered which epoch — see `bundle-gossip.ts` for why a ledger
+   *  is needed at all (the relay broadcasts to the whole mesh, not to one peer). */
+  #bundleOffered = new BundleOfferLedger();
   #port = null;
   #lastError = null;
   /**
@@ -110405,8 +110441,10 @@ var MeshNode = class {
     }
     try {
       this.#engine = new meshCore.MeshEngine(Buffer.from(id.genesis), Buffer.from(id.staticPrivate), Buffer.from(id.cert), 0, Buffer.alloc(16));
-      if (id.bundle)
+      if (id.bundle) {
         this.#engine.setBundle(Buffer.from(id.bundle), Date.now());
+        this.#bundle = id.bundle;
+      }
     } catch (e) {
       this.#engine = null;
       this.#lastError = e instanceof Error ? e.message : String(e);
@@ -110653,6 +110691,8 @@ var MeshNode = class {
           engine.setBundle(bytes2, Date.now());
           this.#stopIfRevoked(engine);
           cacheBundle(new Uint8Array(bytes2), meshDirNameFromWireId(engine.meshId()) ?? void 0);
+          this.#bundle = new Uint8Array(bytes2);
+          this.#bundleOffered.reset();
           break;
         }
       }
@@ -110661,6 +110701,48 @@ var MeshNode = class {
       this.#lastError = e instanceof Error ? e.message : String(e);
     }
   }
+  /**
+   * Offer our policy bundle to a peer whose epoch is older than ours.
+   *
+   * ## The half of gossip that was never written
+   *
+   * `MeshPeerHint.epoch` is documented in the protocol as "the epoch the node advertises,
+   * SO A LAGGING PEER KNOWS TO PULL", and the relay has always carried it. Nothing read
+   * it, and — the part that made this total — nothing in the product ever SENT a
+   * `mesh:bundle`. The broker forwarded a message with no sender anywhere.
+   *
+   * So a node's roster was frozen at the instant it joined. `joinWithToken` caches the
+   * bundle the server returns, which is why a machine works at all; but every machine that
+   * joins LATER is invisible to it forever, because the only thing that would have told it
+   * is the gossip that never happened. On a four-machine network built in join order, the
+   * first machine knew nobody, the last knew everyone, and every one of them reported
+   * itself healthy. That is what this fixes.
+   *
+   * PUSH, not pull, because push needs no new message type and the protocol already hands
+   * us exactly the fact we need — the peer's epoch. For any pair, whoever is ahead offers,
+   * so the direction takes care of itself and a new joiner (who always has the newest
+   * bundle, straight from the server) feeds it to everyone already there.
+   *
+   * Safe by construction: the bundle is CA-signed, so `setBundle` on the receiving side
+   * verifies it against genesis and refuses anything that does not chain. Offering is
+   * therefore never a policy change — the worst a wrong offer costs a peer is a parse.
+   */
+  #offerBundleTo(peerHex, peerEpoch) {
+    const engine = this.#engine;
+    const bundle = this.#bundle;
+    if (!engine || !bundle)
+      return;
+    if (!this.#bundleOffered.claim(peerHex, peerEpoch, engine.policyEpoch()))
+      return;
+    try {
+      sendMesh({
+        type: "mesh:bundle",
+        meshId: engine.meshId(),
+        bundle: Buffer.from(bundle).toString("base64")
+      });
+    } catch {
+    }
+  }
   #learnPeer(p) {
     const engine = this.#engine;
     if (!engine)
@@ -110669,6 +110751,7 @@ var MeshNode = class {
     if (pk.length !== 32)
       return;
     const hex6 = pk.toString("hex");
+    this.#offerBundleTo(hex6, p.epoch ?? 0);
     if (p.cert) {
       try {
         const bytes2 = Buffer.from(p.cert, "base64");

package/dist-bundle/mesh-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fineguide-tesseract/mesh-core",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "main": "index.js",
   "types": "index.d.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",