@fairfox/polly 0.69.0 → 0.70.0

package/dist/tools/test/src/e2e-mesh/index.js

@@ -0,0 +1,1089 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/shared/lib/encryption.ts
+var exports_encryption = {};
+__export(exports_encryption, {
+  sealEnvelope: () => sealEnvelope,
+  openEnvelope: () => openEnvelope,
+  generateDocumentKey: () => generateDocumentKey,
+  encrypt: () => encrypt,
+  encodeEncryptedEnvelope: () => encodeEncryptedEnvelope,
+  decryptOrThrow: () => decryptOrThrow,
+  decrypt: () => decrypt,
+  decodeEncryptedEnvelope: () => decodeEncryptedEnvelope,
+  TAG_BYTES: () => TAG_BYTES,
+  NONCE_BYTES: () => NONCE_BYTES,
+  KEY_BYTES: () => KEY_BYTES,
+  EncryptionError: () => EncryptionError
+});
+import nacl from "tweetnacl";
+function generateDocumentKey() {
+  return nacl.randomBytes(KEY_BYTES);
+}
+function encrypt(payload, key) {
+  if (key.length !== KEY_BYTES) {
+    throw new EncryptionError(`secretbox key must be ${KEY_BYTES} bytes, got ${key.length}.`, "invalid-key-length");
+  }
+  const nonce = nacl.randomBytes(NONCE_BYTES);
+  const ciphertext = nacl.secretbox(payload, nonce, key);
+  const out = new Uint8Array(NONCE_BYTES + ciphertext.length);
+  out.set(nonce, 0);
+  out.set(ciphertext, NONCE_BYTES);
+  return out;
+}
+function decrypt(sealed, key) {
+  if (key.length !== KEY_BYTES) {
+    throw new EncryptionError(`secretbox key must be ${KEY_BYTES} bytes, got ${key.length}.`, "invalid-key-length");
+  }
+  if (sealed.length < NONCE_BYTES + TAG_BYTES) {
+    return;
+  }
+  const nonce = sealed.subarray(0, NONCE_BYTES);
+  const ciphertext = sealed.subarray(NONCE_BYTES);
+  const opened = nacl.secretbox.open(ciphertext, nonce, key);
+  return opened ?? undefined;
+}
+function decryptOrThrow(sealed, key) {
+  const opened = decrypt(sealed, key);
+  if (!opened) {
+    throw new EncryptionError(`Failed to decrypt sealed blob: wrong key, malformed input, or tampered ciphertext.`, "decrypt-failed");
+  }
+  return opened;
+}
+function sealEnvelope(payload, documentId, key) {
+  return {
+    documentId,
+    sealed: encrypt(payload, key)
+  };
+}
+function openEnvelope(envelope, key) {
+  return decryptOrThrow(envelope.sealed, key);
+}
+function encodeEncryptedEnvelope(envelope) {
+  const idBytes = new TextEncoder().encode(envelope.documentId);
+  const out = new Uint8Array(4 + idBytes.length + envelope.sealed.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, idBytes.length, false);
+  out.set(idBytes, 4);
+  out.set(envelope.sealed, 4 + idBytes.length);
+  return out;
+}
+function decodeEncryptedEnvelope(bytes) {
+  if (bytes.length < 4) {
+    throw new EncryptionError(`Encrypted envelope too short: ${bytes.length} bytes.`, "envelope-malformed");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const idLen = view.getUint32(0, false);
+  if (bytes.length < 4 + idLen) {
+    throw new EncryptionError(`Encrypted envelope truncated: declared id length ${idLen}, total ${bytes.length}.`, "envelope-malformed");
+  }
+  const documentId = new TextDecoder().decode(bytes.subarray(4, 4 + idLen));
+  const sealed = bytes.slice(4 + idLen);
+  return { documentId, sealed };
+}
+var KEY_BYTES = 32, NONCE_BYTES = 24, TAG_BYTES = 16, EncryptionError;
+var init_encryption = __esm(() => {
+  EncryptionError = class EncryptionError extends Error {
+    code;
+    constructor(message, code) {
+      super(message);
+      this.name = "EncryptionError";
+      this.code = code;
+    }
+  };
+});
+
+// tools/test/src/e2e-mesh/console-allowlist.ts
+var MESH_CONSOLE_ALLOWLIST = [
+  {
+    match: "[polly#107 H5]",
+    reason: "polly#107 H5 warning fires whenever $meshState resolves against an unconfigured module instance during normal warmup; the issue tracks the longer fix."
+  },
+  {
+    match: "automerge",
+    level: "log",
+    reason: "Automerge logs its own version banner at log level on first import; benign."
+  },
+  {
+    match: "using deprecated parameters for `initSync()`",
+    reason: "Automerge WASM bundler emits a deprecation warning on first init; upstream noise polly cannot suppress without a forked bundle."
+  },
+  {
+    match: "Failed to load resource",
+    level: "error",
+    reason: "Puppeteer logs a 404 for /favicon.ico against the in-tree consumer because the consumer does not ship one; the e2e harness only cares about app-level errors."
+  }
+];
+function isAllowedConsoleLine(line, allowlist = MESH_CONSOLE_ALLOWLIST) {
+  for (const entry of allowlist) {
+    if (entry.level && entry.level !== line.level)
+      continue;
+    if (typeof entry.match === "string") {
+      if (line.text.includes(entry.match))
+        return true;
+    } else if (entry.match.test(line.text)) {
+      return true;
+    }
+  }
+  return false;
+}
+// tools/test/src/e2e-mesh/keys.ts
+init_encryption();
+
+// src/shared/lib/signing.ts
+import nacl2 from "tweetnacl";
+var PUBLIC_KEY_BYTES = 32;
+var SECRET_KEY_BYTES = 64;
+var SIGNATURE_BYTES = 64;
+
+class SigningError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "SigningError";
+    this.code = code;
+  }
+}
+function generateSigningKeyPair() {
+  const pair = nacl2.sign.keyPair();
+  return {
+    publicKey: pair.publicKey,
+    secretKey: pair.secretKey
+  };
+}
+function signingKeyPairFromSecret(secretKey) {
+  if (secretKey.length !== SECRET_KEY_BYTES) {
+    throw new SigningError(`Ed25519 secret key must be ${SECRET_KEY_BYTES} bytes, got ${secretKey.length}.`, "invalid-secret-key");
+  }
+  const pair = nacl2.sign.keyPair.fromSecretKey(secretKey);
+  return {
+    publicKey: pair.publicKey,
+    secretKey: pair.secretKey
+  };
+}
+function sign(payload, secretKey) {
+  if (secretKey.length !== SECRET_KEY_BYTES) {
+    throw new SigningError(`Ed25519 secret key must be ${SECRET_KEY_BYTES} bytes, got ${secretKey.length}.`, "invalid-secret-key");
+  }
+  return nacl2.sign.detached(payload, secretKey);
+}
+function verify(payload, signature, publicKey) {
+  if (publicKey.length !== PUBLIC_KEY_BYTES) {
+    throw new SigningError(`Ed25519 public key must be ${PUBLIC_KEY_BYTES} bytes, got ${publicKey.length}.`, "invalid-public-key");
+  }
+  if (signature.length !== SIGNATURE_BYTES) {
+    throw new SigningError(`Ed25519 signature must be ${SIGNATURE_BYTES} bytes, got ${signature.length}.`, "invalid-signature-length");
+  }
+  return nacl2.sign.detached.verify(payload, signature, publicKey);
+}
+function signEnvelope(payload, senderId, secretKey) {
+  const signature = sign(payload, secretKey);
+  return { senderId, payload, signature };
+}
+function openEnvelope2(envelope, publicKey) {
+  const ok = verify(envelope.payload, envelope.signature, publicKey);
+  if (!ok) {
+    throw new SigningError(`Signature verification failed for envelope from ${envelope.senderId}.`, "envelope-malformed");
+  }
+  return envelope.payload;
+}
+function encodeSignedEnvelope(envelope) {
+  const senderBytes = new TextEncoder().encode(envelope.senderId);
+  const total = 4 + senderBytes.length + SIGNATURE_BYTES + envelope.payload.length;
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, senderBytes.length, false);
+  out.set(senderBytes, 4);
+  out.set(envelope.signature, 4 + senderBytes.length);
+  out.set(envelope.payload, 4 + senderBytes.length + SIGNATURE_BYTES);
+  return out;
+}
+function decodeSignedEnvelope(bytes) {
+  if (bytes.length < 4 + SIGNATURE_BYTES) {
+    throw new SigningError(`Envelope too short: ${bytes.length} bytes, need at least ${4 + SIGNATURE_BYTES}.`, "envelope-malformed");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const senderLen = view.getUint32(0, false);
+  if (bytes.length < 4 + senderLen + SIGNATURE_BYTES) {
+    throw new SigningError(`Envelope truncated: declared sender length ${senderLen}, total ${bytes.length}.`, "envelope-malformed");
+  }
+  const senderId = new TextDecoder().decode(bytes.subarray(4, 4 + senderLen));
+  const signature = bytes.slice(4 + senderLen, 4 + senderLen + SIGNATURE_BYTES);
+  const payload = bytes.slice(4 + senderLen + SIGNATURE_BYTES);
+  return { senderId, payload, signature };
+}
+
+// tools/test/src/e2e-mesh/keys.ts
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0;i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function prebakeKeyringPair(peerIdA = "peer-a", peerIdB = "peer-b") {
+  const set = prebakeKeyringSet([peerIdA, peerIdB]);
+  return {
+    peers: [set.peers[0], set.peers[1]],
+    docKeyB64: set.docKeyB64
+  };
+}
+function prebakeKeyringSet(peerIds) {
+  if (peerIds.length < 2) {
+    throw new Error("prebakeKeyringSet: at least two peer ids required");
+  }
+  const docKey = generateDocumentKey();
+  const peers = peerIds.map((peerId) => {
+    const pair = generateSigningKeyPair();
+    return {
+      peerId,
+      identitySecretKeyB64: toBase64(pair.secretKey),
+      identityPublicKeyB64: toBase64(pair.publicKey)
+    };
+  });
+  return { peers, docKeyB64: toBase64(docKey) };
+}
+function knownPeersFor(set, thisPeerId) {
+  const out = {};
+  for (const peer of set.peers) {
+    if (peer.peerId === thisPeerId)
+      continue;
+    out[peer.peerId] = peer.identityPublicKeyB64;
+  }
+  return out;
+}
+// tools/test/src/e2e-mesh/launch-peer.ts
+var {existsSync, mkdirSync, rmSync} = (() => ({}));
+
+// node:os
+var tmpdir = function() {
+  return "/tmp";
+};
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// tools/test/src/e2e-mesh/launch-peer.ts
+import puppeteer from "puppeteer";
+
+// src/shared/lib/mesh-diagnostics.ts
+var listeners = new Set;
+function emitMeshDiagnostic(diagnostic) {
+  const event = { ...diagnostic, timestamp: Date.now() };
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch {}
+  }
+}
+function subscribeToMeshDiagnostics(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function recordMeshDiagnostics() {
+  const captured = [];
+  const stop = subscribeToMeshDiagnostics((event) => {
+    captured.push(event);
+  });
+  return { events: captured, stop };
+}
+
+// tools/test/src/e2e-mesh/mesh-assertions.ts
+class MeshAssertionError extends Error {
+  kind = "mesh-assertion-failure";
+  unexpected;
+  constructor(message, unexpected) {
+    super(message);
+    this.name = "MeshAssertionError";
+    this.unexpected = unexpected;
+  }
+}
+function startDiagnosticRecorder() {
+  const { events, stop } = recordMeshDiagnostics();
+  function assertNoSilentDrops(allow = []) {
+    const allowed = new Set(allow);
+    const unexpected = events.filter((event) => event.kind.startsWith("drop:") && !allowed.has(event.kind));
+    if (unexpected.length === 0)
+      return;
+    const summary = unexpected.map((event) => `  ${event.kind} ${JSON.stringify(eventDetails(event))}`).join(`
+`);
+    throw new MeshAssertionError(`Unexpected silent-drop diagnostics fired during the e2e run.
+${summary}
+` + `If a drop kind is legitimately expected for this scenario, pass it ` + `to assertNoSilentDrops({ allow: [...] }).`, unexpected);
+  }
+  return { events, stop, assertNoSilentDrops };
+}
+function eventDetails(event) {
+  const { kind: _kind, timestamp: _ts, ...rest } = event;
+  return rest;
+}
+
+// tools/test/src/e2e-mesh/launch-peer.ts
+var READY_POLL_MS = 100;
+function profileDir(parent, peerId) {
+  const safePeerId = peerId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return resolve(parent, `polly-e2e-${safePeerId}-${Date.now()}`);
+}
+async function launchPeer(options) {
+  const {
+    peerId,
+    consumerUrl,
+    headless = process.env["HEADLESS"] !== "false",
+    consoleAllowlist = MESH_CONSOLE_ALLOWLIST,
+    readyTimeoutMs = 15000,
+    profileParent = resolve(tmpdir(), "polly-e2e")
+  } = options;
+  if (!existsSync(profileParent))
+    mkdirSync(profileParent, { recursive: true });
+  const userDataDir = profileDir(profileParent, peerId);
+  if (existsSync(userDataDir)) {
+    rmSync(userDataDir, { recursive: true, force: true });
+  }
+  const browser = await puppeteer.launch({
+    headless,
+    userDataDir,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  const page = await browser.newPage();
+  const consoleLines = [];
+  const pageErrors = [];
+  page.on("console", (msg) => {
+    const level = msg.type();
+    const text = msg.text();
+    const allowed = isAllowedConsoleLine({ level, text }, consoleAllowlist);
+    consoleLines.push({ level, text, allowed });
+  });
+  page.on("pageerror", (err) => {
+    pageErrors.push(err instanceof Error ? err.message : String(err));
+  });
+  await page.goto(consumerUrl, { waitUntil: "domcontentloaded" });
+  const deadline = Date.now() + readyTimeoutMs;
+  let ready = false;
+  let lastStatus = "";
+  while (Date.now() < deadline) {
+    lastStatus = await page.evaluate(() => document.querySelector("[data-e2e='status']")?.textContent ?? "");
+    if (lastStatus === "ready") {
+      ready = true;
+      break;
+    }
+    if (lastStatus.startsWith("error") || lastStatus.startsWith("bootstrap-failed")) {
+      await browser.close();
+      rmSync(userDataDir, { recursive: true, force: true });
+      throw new Error(`launchPeer(${peerId}): consumer reported "${lastStatus}"`);
+    }
+    await new Promise((r) => setTimeout(r, READY_POLL_MS));
+  }
+  if (!ready) {
+    await browser.close();
+    rmSync(userDataDir, { recursive: true, force: true });
+    throw new Error(`launchPeer(${peerId}): consumer did not reach "ready" within ${readyTimeoutMs}ms (last status: "${lastStatus}")`);
+  }
+  function assertNoUnexpectedConsole() {
+    const bad = consoleLines.filter((line) => !line.allowed && (line.level === "error" || line.level === "warn" || line.level === "warning"));
+    if (bad.length > 0) {
+      const summary = bad.map((l) => `  [${l.level}] ${l.text}`).join(`
+`);
+      throw new Error(`launchPeer(${peerId}): unexpected console output:
+${summary}`);
+    }
+    if (pageErrors.length > 0) {
+      throw new Error(`launchPeer(${peerId}): page errors:
+${pageErrors.map((e) => `  ${e}`).join(`
+`)}`);
+    }
+  }
+  async function collectDiagnostics() {
+    const events = await page.evaluate(() => {
+      const w = window;
+      return w.__pollyE2eDiagnostics ? [...w.__pollyE2eDiagnostics] : [];
+    });
+    return events;
+  }
+  async function assertNoSilentDrops(allow = []) {
+    const allowed = new Set(allow);
+    const events = await collectDiagnostics();
+    const unexpected = events.filter((event) => event.kind.startsWith("drop:") && !allowed.has(event.kind));
+    if (unexpected.length === 0)
+      return;
+    const summary = unexpected.map((event) => {
+      const { kind, timestamp: _ts, ...rest } = event;
+      return `  ${kind} ${JSON.stringify(rest)}`;
+    }).join(`
+`);
+    throw new MeshAssertionError(`launchPeer(${peerId}): unexpected silent-drop diagnostics fired during the e2e run.
+${summary}
+` + `If a drop kind is legitimately expected, pass it to peer.assertNoSilentDrops([...]).`, unexpected);
+  }
+  let closed = false;
+  return {
+    peerId,
+    page,
+    console: consoleLines,
+    pageErrors,
+    assertNoUnexpectedConsole,
+    collectDiagnostics,
+    assertNoSilentDrops,
+    close: async () => {
+      if (closed)
+        return;
+      closed = true;
+      try {
+        await page.close();
+      } catch {}
+      try {
+        await browser.close();
+      } catch {}
+      try {
+        rmSync(userDataDir, { recursive: true, force: true });
+      } catch {}
+    }
+  };
+}
+// tools/test/src/e2e-mesh/serve-consumer.ts
+var {readFileSync} = (() => ({}));
+var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/test/src/e2e-mesh";
+var pollyRoot = resolve(__dirname, "../../../..");
+var consumerEntry = resolve(pollyRoot, "examples/e2e-consumer/main.ts");
+var consumerHtml = resolve(pollyRoot, "examples/e2e-consumer/index.html");
+var automergeBase64Path = resolve(pollyRoot, "node_modules/@automerge/automerge/dist/mjs/entrypoints/fullfat_base64.js");
+var automergeBase64Plugin = {
+  name: "automerge-base64",
+  setup(build) {
+    build.onResolve({ filter: /^@automerge\/automerge(\/slim)?$/ }, () => ({
+      path: automergeBase64Path
+    }));
+  }
+};
+async function serveConsumer(options) {
+  const buildResult = await Bun.build({
+    entrypoints: [consumerEntry],
+    target: "browser",
+    format: "esm",
+    minify: false,
+    sourcemap: "inline",
+    plugins: [automergeBase64Plugin]
+  });
+  if (!buildResult.success) {
+    const logs = buildResult.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`serveConsumer: build failed:
+${logs}`);
+  }
+  const jsText = await buildResult.outputs[0]?.text();
+  if (!jsText) {
+    throw new Error("serveConsumer: build produced no output");
+  }
+  const rawHtml = readFileSync(consumerHtml, "utf-8");
+  const bootstrapJson = JSON.stringify(options.bootstrap);
+  const bootstrapShim = `<script>window.__pollyE2eBootstrap = ${bootstrapJson};</script>`;
+  const html = rawHtml.replace(/<script type="module" src="\.\/main\.js"><\/script>/, `${bootstrapShim}
+    <script type="module" src="./main.js"></script>`);
+  const server = Bun.serve({
+    port: 0,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        return new Response(html, { headers: { "Content-Type": "text/html" } });
+      }
+      if (url.pathname === "/main.js") {
+        return new Response(jsText, {
+          headers: { "Content-Type": "application/javascript" }
+        });
+      }
+      return new Response("not found", { status: 404 });
+    }
+  });
+  return {
+    url: `http://127.0.0.1:${server.port}/`,
+    close: async () => {
+      server.stop();
+    }
+  };
+}
+// tools/test/src/e2e-mesh/wait-for-convergence.ts
+async function readPeerSnapshot(peer) {
+  return peer.page.evaluate(() => {
+    const itemEls = Array.from(document.querySelectorAll("[data-e2e-item]"));
+    const items = itemEls.map((el) => el.textContent ?? "");
+    const peerCountText = document.querySelector("[data-e2e='peer-count']")?.textContent ?? "0";
+    const status = document.querySelector("[data-e2e='status']")?.textContent ?? "";
+    return { items, peerCount: Number(peerCountText) || 0, status };
+  }).then((data) => ({ peerId: peer.peerId, ...data }));
+}
+async function waitForConvergence(peers, predicate, options = {}) {
+  const { timeoutMs = 20000, pollMs = 200 } = options;
+  const deadline = Date.now() + timeoutMs;
+  let lastSnapshots = [];
+  while (Date.now() < deadline) {
+    const snapshots = await Promise.all(peers.map(readPeerSnapshot));
+    lastSnapshots = snapshots;
+    if (snapshots.every(predicate))
+      return;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  const summary = lastSnapshots.map((s) => `  ${s.peerId}: status="${s.status}" peerCount=${s.peerCount} items=${JSON.stringify(s.items)}`).join(`
+`);
+  throw new Error(`waitForConvergence: predicate did not hold for every peer within ${timeoutMs}ms.
+${summary}`);
+}
+async function waitForMeshConnected(peers, options = {}) {
+  const minPeers = peers.length - 1;
+  await waitForConvergence(peers, (snapshot) => snapshot.peerCount >= minPeers, options);
+}
+// tools/test/src/e2e-mesh/with-relay.ts
+import { Elysia as Elysia2 } from "elysia";
+
+// src/elysia/signaling-server-plugin.ts
+import { Elysia } from "elysia";
+function signalingServer(options = {}) {
+  const path = options.path ?? "/polly/signaling";
+  const onCustomFrame = options.onCustomFrame;
+  const peerSockets = new Map;
+  const parseMessage = (raw) => {
+    try {
+      return typeof raw === "string" ? JSON.parse(raw) : raw;
+    } catch {
+      return;
+    }
+  };
+  const handleJoin = (ws, peerId) => {
+    const newcomer = ws;
+    const incumbents = [];
+    for (const [existingPeerId, existingSocket] of peerSockets) {
+      if (existingPeerId === peerId)
+        continue;
+      incumbents.push({ peerId: existingPeerId, socket: existingSocket });
+    }
+    peerSockets.set(peerId, newcomer);
+    const wsWithData = ws;
+    wsWithData.data.peerId = peerId;
+    newcomer.send({
+      type: "peers-present",
+      peerIds: incumbents.map((i) => i.peerId)
+    });
+    for (const incumbent of incumbents) {
+      try {
+        incumbent.socket.send({ type: "peer-joined", peerId });
+      } catch {}
+    }
+  };
+  const sendUnknownTarget = (ws, targetPeerId) => {
+    ws.send({
+      type: "error",
+      reason: "unknown-target",
+      targetPeerId
+    });
+  };
+  const findOpenTarget = (targetPeerId) => {
+    const target = peerSockets.get(targetPeerId);
+    if (!target)
+      return;
+    const readyState = target.readyState;
+    const OPEN = 1;
+    if (readyState !== undefined && readyState !== OPEN) {
+      peerSockets.delete(targetPeerId);
+      return;
+    }
+    return target;
+  };
+  const handleSignal = (ws, msg) => {
+    const wsWithData = ws;
+    const senderId = wsWithData.data.peerId;
+    if (!senderId) {
+      wsWithData.send({ type: "error", reason: "not-joined" });
+      return;
+    }
+    const target = findOpenTarget(msg.targetPeerId);
+    if (!target) {
+      sendUnknownTarget(ws, msg.targetPeerId);
+      return;
+    }
+    const relayed = {
+      type: "signal",
+      peerId: senderId,
+      targetPeerId: msg.targetPeerId,
+      payload: msg.payload
+    };
+    try {
+      target.send(relayed);
+    } catch {
+      peerSockets.delete(msg.targetPeerId);
+      sendUnknownTarget(ws, msg.targetPeerId);
+    }
+  };
+  return new Elysia().ws(path, {
+    message(ws, raw) {
+      const msg = parseMessage(raw);
+      if (!msg) {
+        ws.send({ type: "error", reason: "malformed" });
+        return;
+      }
+      if (msg.type === "join") {
+        handleJoin(ws, msg.peerId);
+        return;
+      }
+      if (msg.type === "signal") {
+        handleSignal(ws, msg);
+        return;
+      }
+      if (onCustomFrame !== undefined) {
+        const wsWithData = ws;
+        const senderId = wsWithData.data["peerId"];
+        const peerId = typeof senderId === "string" ? senderId : undefined;
+        onCustomFrame(wsWithData, msg, peerId);
+        return;
+      }
+      ws.send({ type: "error", reason: "malformed" });
+    },
+    close(ws) {
+      const peerId = ws.data.peerId;
+      if (!peerId) {
+        return;
+      }
+      const mapped = peerSockets.get(peerId);
+      const wsData = ws.data;
+      const mappedData = mapped?.data;
+      if (mapped === undefined || mappedData !== wsData) {
+        return;
+      }
+      peerSockets.delete(peerId);
+      for (const [_incumbentId, incumbentSocket] of peerSockets) {
+        try {
+          incumbentSocket.send({ type: "peer-left", peerId });
+        } catch {}
+      }
+    }
+  });
+}
+
+// tools/test/src/e2e-mesh/with-relay.ts
+function pickPort() {
+  return 30000 + Math.floor(Math.random() * 1e4);
+}
+async function withRelay(options = {}) {
+  const mode = options.mode ?? "embedded";
+  const path = options.path ?? "/polly/signaling";
+  if (mode === "env") {
+    const url2 = process.env["SIGNALING_URL"];
+    if (!url2) {
+      throw new Error("withRelay({ mode: 'env' }) requires SIGNALING_URL to be set in the environment.");
+    }
+    return {
+      url: url2,
+      close: async () => {}
+    };
+  }
+  const port = pickPort();
+  const app = new Elysia2().use(signalingServer({ path })).listen(port);
+  const url = `ws://127.0.0.1:${port}${path}`;
+  return {
+    url,
+    close: async () => {
+      app.server?.stop?.(true);
+    }
+  };
+}
+export {
+  withRelay,
+  waitForMeshConnected,
+  waitForConvergence,
+  startDiagnosticRecorder,
+  serveConsumer,
+  prebakeKeyringSet,
+  prebakeKeyringPair,
+  launchPeer,
+  knownPeersFor,
+  isAllowedConsoleLine,
+  MeshAssertionError,
+  MESH_CONSOLE_ALLOWLIST
+};
+
+//# debugId=7F448F738B995B3064756E2164756E21