@blamejs/blamejs-shop 0.0.44

package/lib/vendor/blamejs/test/layer-0-primitives/crypto-base64url.test.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * b.crypto.toBase64Url + b.crypto.fromBase64Url — RFC 4648 §5
+ * base64url encode/decode routed through Node's built-in encoding.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+function testSurface() {
+  check("toBase64Url is fn",   typeof b.crypto.toBase64Url === "function");
+  check("fromBase64Url is fn", typeof b.crypto.fromBase64Url === "function");
+}
+
+function testRoundTripBuffer() {
+  var buf = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
+  var enc = b.crypto.toBase64Url(buf);
+  check("encode produces base64url shape (no padding)",
+    typeof enc === "string" && enc.indexOf("=") === -1 && enc.indexOf("+") === -1 && enc.indexOf("/") === -1);
+  var dec = b.crypto.fromBase64Url(enc);
+  check("decode round-trips to original bytes",
+    Buffer.isBuffer(dec) && dec.equals(buf));
+}
+
+function testEncodeAcceptsString() {
+  var enc = b.crypto.toBase64Url("hello");
+  check("encode from string produces aGVsbG8", enc === "aGVsbG8");
+}
+
+function testEncodeAcceptsUint8Array() {
+  var u8 = new Uint8Array([0x66, 0x6f, 0x6f]);
+  var enc = b.crypto.toBase64Url(u8);
+  check("encode from Uint8Array produces Zm9v", enc === "Zm9v");
+}
+
+function testEncodeRefusesBadShape() {
+  var threw = null;
+  try { b.crypto.toBase64Url(123); } catch (e) { threw = e; }
+  check("encode refuses number input", threw && threw.message.indexOf("must be Buffer") !== -1);
+}
+
+function testDecodeRefusesBadShape() {
+  var threw = null;
+  try { b.crypto.fromBase64Url(123); } catch (e) { threw = e; }
+  check("decode refuses non-string input", threw && threw.message.indexOf("must be a string") !== -1);
+}
+
+function testNoTrailingPadding() {
+  // base64url MUST strip the `=` padding (RFC 4648 §5). The Node
+  // built-in "base64url" encoding does this; the test verifies it
+  // for a payload that base64 would normally pad.
+  // 4 bytes → 6 base64 chars + 2 padding `=` in standard b64;
+  // base64url drops the padding.
+  var enc = b.crypto.toBase64Url(Buffer.from([0xff, 0xff, 0xff, 0xff]));
+  check("4-byte payload yields no trailing =", enc.indexOf("=") === -1);
+}
+
+function testRoundTripWithUrlSafeChars() {
+  // Bytes that produce `+` and `/` in standard base64 must become
+  // `-` and `_` in base64url.
+  var buf = Buffer.from([0xfb, 0xff, 0xbf]);  // → "+/+/" pattern in std b64
+  var enc = b.crypto.toBase64Url(buf);
+  check("base64url uses '-' instead of '+'", enc.indexOf("+") === -1);
+  check("base64url uses '_' instead of '/'", enc.indexOf("/") === -1);
+  var dec = b.crypto.fromBase64Url(enc);
+  check("round-trip preserves bytes", dec.equals(buf));
+}
+
+function run() {
+  testSurface();
+  testRoundTripBuffer();
+  testEncodeAcceptsString();
+  testEncodeAcceptsUint8Array();
+  testEncodeRefusesBadShape();
+  testDecodeRefusesBadShape();
+  testNoTrailingPadding();
+  testRoundTripWithUrlSafeChars();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  try { run(); console.log("[crypto-base64url] OK"); }
+  catch (e) { process.stderr.write("FAIL: " + (e && e.stack || e) + "\n"); process.exit(1); }
+}

package/lib/vendor/blamejs/test/layer-0-primitives/crypto-envelope.test.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * b.crypto envelope wire format — FixedInfo-bound KDF + 4-byte
+ * envelope-header AAD round trip. The decrypt path reconstructs
+ * both bindings from the envelope prefix; a tampered header
+ * surfaces as a Poly1305 tag failure.
+ */
+
+var helpers = require("../helpers");
+var b      = helpers.b;
+var check  = helpers.check;
+
+// _mintLegacyEnvelope0xE1 was removed from the public `b.crypto.*`
+// surface in v0.9.58 (CRYPTO-17). Test-only fixture; production code
+// never mints legacy envelopes.
+var legacyFixtures = require("../../lib/_test/crypto-fixtures");
+
+async function run() {
+  var keys = b.crypto.generateEncryptionKeyPair();
+  var ct = b.crypto.encrypt("blamejs envelope test", keys);
+  var pt = b.crypto.decrypt(ct, keys);
+  check("crypto.encrypt → decrypt round trip", pt === "blamejs envelope test");
+
+  var raw = Buffer.from(ct, "base64");
+  check("envelope magic byte = 0xE2 (FixedInfo-bound)", raw[0] === 0xE2);
+
+  // Tamper with the cipherId byte — bypasses the unsupported-cipher
+  // check (since the same id is the only one accepted) and forces
+  // the Poly1305 tag check on the AAD-bound header to fail.
+  var tampered = Buffer.from(raw);
+  tampered[2] = (tampered[2] ^ 0x01) & 0xff;                                       // allow:raw-byte-literal — single-bit flip in cipherId
+  var threw;
+  try { b.crypto.decrypt(tampered.toString("base64"), keys); }
+  catch (e) { threw = e; }
+  check("decrypt refuses header-tampered envelope",
+    threw && /unsupported|invalid|tag|auth/i.test(threw.message));
+
+  // Legacy 0xE1 envelope — refused by default.
+  var legacy = Buffer.alloc(64);
+  legacy[0] = 0xE1;
+  var threwLegacy;
+  try { b.crypto.decrypt(legacy.toString("base64"), keys); }
+  catch (e) { threwLegacy = e; }
+  check("decrypt refuses legacy 0xE1 envelope by default",
+    threwLegacy && /legacy 0xE1|FixedInfo/i.test(threwLegacy.message));
+
+  // Legacy 0xE1 envelope — refusal message points operators at the
+  // allowLegacy opt-in for migration.
+  check("decrypt refusal hints at allowLegacy migration path",
+    threwLegacy && /allowLegacy/.test(threwLegacy.message));
+
+  // Round-trip an actual 0xE1-shape envelope under allowLegacy: true.
+  // Mint by sealing under the production encrypt() and patching:
+  //   - magic byte 0xE2 → 0xE1
+  //   - re-derive the symmetricKey from the same KEM material WITHOUT
+  //     FixedInfo (pre-bump KDF input shape), re-encrypt the body,
+  //     re-emit the envelope.
+  // This is test-only — operators never mint 0xE1; they only READ it.
+  var fixturePlaintext = "legacy-payload";
+  var fixtureBlob = legacyFixtures.mintLegacyEnvelope0xE1(fixturePlaintext, {
+    publicKey:   keys.publicKey,
+    ecPublicKey: keys.ecPublicKey,
+  });
+  var opened = b.crypto.decrypt(fixtureBlob, keys, { allowLegacy: true });
+  check("decrypt round-trips a 0xE1 envelope under allowLegacy",
+    opened === fixturePlaintext);
+
+  // allowLegacy: true on a current 0xE2 envelope does not change behavior.
+  var currentBlob = b.crypto.encrypt("not-legacy", {
+    publicKey:   keys.publicKey,
+    ecPublicKey: keys.ecPublicKey,
+  });
+  var openedCurrent = b.crypto.decrypt(currentBlob, keys, { allowLegacy: true });
+  check("decrypt with allowLegacy still opens current envelope",
+    openedCurrent === "not-legacy");
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("[crypto-envelope] OK"); },
+    function (e) { console.error(e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/crypto-hash-files-parallel.test.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * b.crypto.hashFilesParallel — parallel single-pass multi-digest hashing
+ * for many files (SBOM regeneration, vendor-data integrity sweeps,
+ * release-asset bundling). See lib/crypto.js for the surface contract.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+var fs   = require("node:fs");
+var os   = require("node:os");
+var path = require("node:path");
+var nc   = require("node:crypto");
+
+function _scratch(label) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "hashparallel-" + label + "-"));
+}
+
+function _writeBytes(dir, name, byteLength) {
+  var p = path.join(dir, name);
+  fs.writeFileSync(p, nc.randomBytes(byteLength));
+  return p;
+}
+
+function _expectedHex(filePath, alg) {
+  return nc.createHash(alg).update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function testSurface() {
+  check("hashFilesParallel is fn", typeof b.crypto.hashFilesParallel === "function");
+}
+
+async function testHappyPath() {
+  var dir = _scratch("happy");
+  try {
+    var paths = [
+      _writeBytes(dir, "a.bin", 1024),
+      _writeBytes(dir, "b.bin", 4096),
+      _writeBytes(dir, "c.bin", 17),
+    ];
+    var rows = await b.crypto.hashFilesParallel(paths);
+    check("result is array of correct length", Array.isArray(rows) && rows.length === paths.length);
+    for (var i = 0; i < paths.length; i += 1) {
+      check("row " + i + ": path preserved", rows[i].path === paths[i]);
+      check("row " + i + ": byteLength accurate", rows[i].byteLength === fs.statSync(paths[i]).size);
+      check("row " + i + ": sha256 matches reference",   rows[i].sha256   === _expectedHex(paths[i], "sha256"));
+      check("row " + i + ": sha3_512 matches reference", rows[i].sha3_512 === _expectedHex(paths[i], "sha3-512"));
+    }
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testOrderPreserved() {
+  var dir = _scratch("order");
+  try {
+    var paths = [];
+    for (var i = 0; i < 10; i += 1) {
+      paths.push(_writeBytes(dir, "f" + i + ".bin", 64 + i));
+    }
+    var rows = await b.crypto.hashFilesParallel(paths, { concurrency: 4 });
+    var ordered = true;
+    for (var j = 0; j < paths.length; j += 1) {
+      if (rows[j].path !== paths[j]) ordered = false;
+    }
+    check("rows match input order under concurrency", ordered);
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testCustomAlgorithms() {
+  var dir = _scratch("alg");
+  try {
+    var p = _writeBytes(dir, "a.bin", 256);
+    var rows = await b.crypto.hashFilesParallel([p], { algorithms: ["sha512"] });
+    check("custom alg: only sha512 emitted", rows[0].sha512 && !rows[0].sha256);
+    check("custom alg: matches reference",   rows[0].sha512 === _expectedHex(p, "sha512"));
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testProgressCallback() {
+  var dir = _scratch("progress");
+  try {
+    var paths = [
+      _writeBytes(dir, "a.bin", 64),
+      _writeBytes(dir, "b.bin", 128),
+      _writeBytes(dir, "c.bin", 256),
+    ];
+    var calls = [];
+    await b.crypto.hashFilesParallel(paths, {
+      onProgress: function (completed, total) { calls.push({ c: completed, t: total }); },
+    });
+    check("onProgress fired N times", calls.length === paths.length);
+    check("onProgress reached total",  calls[calls.length - 1].c === paths.length);
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testProgressCallbackErrorsSwallowed() {
+  var dir = _scratch("progress-throw");
+  try {
+    var p = _writeBytes(dir, "a.bin", 32);
+    var rows = await b.crypto.hashFilesParallel([p], {
+      onProgress: function () { throw new Error("progress callback exploded"); },
+    });
+    check("progress-throw: result still produced", rows.length === 1 && typeof rows[0].sha256 === "string");
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testEmptyArray() {
+  var rows = await b.crypto.hashFilesParallel([]);
+  check("empty paths: returns empty array", Array.isArray(rows) && rows.length === 0);
+}
+
+async function testBadInputs() {
+  async function expectReject(label, p, msgMatch) {
+    var threw = null;
+    try { await p; } catch (e) { threw = e; }
+    check(label, threw && (threw.message || "").indexOf(msgMatch) !== -1);
+  }
+  await expectReject("non-array filePaths refused",
+    b.crypto.hashFilesParallel("not-an-array"),
+    "filePaths must be an array");
+  await expectReject("empty-string entry refused",
+    b.crypto.hashFilesParallel(["valid", ""]),
+    "filePaths[1] must be a non-empty string");
+  await expectReject("non-array algorithms refused",
+    b.crypto.hashFilesParallel(["x"], { algorithms: "sha256" }),
+    "opts.algorithms must be a non-empty array");
+  await expectReject("zero-length algorithms refused",
+    b.crypto.hashFilesParallel(["x"], { algorithms: [] }),
+    "opts.algorithms must be a non-empty array");
+  await expectReject("bad-shape algorithm entry refused",
+    b.crypto.hashFilesParallel(["x"], { algorithms: [""] }),
+    "opts.algorithms[0] must be a non-empty string");
+  await expectReject("concurrency 0 refused",
+    b.crypto.hashFilesParallel(["x"], { concurrency: 0 }),
+    "opts.concurrency must be an integer in [1, 256]");
+  await expectReject("concurrency 999 refused",
+    b.crypto.hashFilesParallel(["x"], { concurrency: 999 }),
+    "opts.concurrency must be an integer in [1, 256]");
+  await expectReject("non-fn onProgress refused",
+    b.crypto.hashFilesParallel(["x"], { onProgress: "not-fn" }),
+    "opts.onProgress must be a function");
+}
+
+async function testUnknownAlgorithm() {
+  var dir = _scratch("badalg");
+  try {
+    var p = _writeBytes(dir, "a.bin", 8);
+    var threw = null;
+    try { await b.crypto.hashFilesParallel([p], { algorithms: ["sha-bogus"] }); }
+    catch (e) { threw = e; }
+    check("unknown algorithm rejected", threw && /unknown algorithm/.test(threw.message));
+  } finally {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+async function testMissingFile() {
+  var threw = null;
+  try { await b.crypto.hashFilesParallel(["/no-such-file-12345"]); }
+  catch (e) { threw = e; }
+  check("missing file rejected", threw !== null);
+}
+
+async function run() {
+  testSurface();
+  await testHappyPath();
+  await testOrderPreserved();
+  await testCustomAlgorithms();
+  await testProgressCallback();
+  await testProgressCallbackErrorsSwallowed();
+  await testEmptyArray();
+  await testBadInputs();
+  await testUnknownAlgorithm();
+  await testMissingFile();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/crypto-hash-stream.test.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * b.crypto.hashFile + b.crypto.hashStream — streaming digest from
+ * disk and arbitrary Readables. Exercises algorithm allowlist,
+ * buffer-shaped digest output, and round-trip equivalence with
+ * the synchronous hash path.
+ */
+
+var fs   = require("fs");
+var os   = require("os");
+var path = require("path");
+var nodeCrypto = require("crypto");
+var { Readable } = require("stream");
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+
+async function run() {
+  // ---- Surface ----
+  check("crypto.hashFile is fn",   typeof b.crypto.hashFile === "function");
+  check("crypto.hashStream is fn", typeof b.crypto.hashStream === "function");
+
+  // ---- Default algorithm = sha3-512 → 64-byte digest ----
+  var tmp = path.join(os.tmpdir(), "blamejs-hashfile-" + Date.now() + ".txt");
+  var payload = "hello blamejs streaming hash";
+  fs.writeFileSync(tmp, payload);
+
+  try {
+    var fileDigest = await b.crypto.hashFile(tmp);
+    check("hashFile returns Buffer",                 Buffer.isBuffer(fileDigest));
+    check("hashFile sha3-512 default → 64 bytes",    fileDigest.length === 64);
+
+    // Cross-check against direct nodeCrypto SHA3-512 of the same bytes.
+    var expected = nodeCrypto.createHash("sha3-512").update(payload).digest();
+    check("hashFile digest matches direct sha3-512", fileDigest.equals(expected));
+
+    // ---- Explicit algorithm: sha512 (interop) ----
+    var sha512Digest = await b.crypto.hashFile(tmp, "sha512");
+    check("hashFile sha512 → 64 bytes",              sha512Digest.length === 64);
+    check("hashFile sha512 differs from sha3-512",   !sha512Digest.equals(fileDigest));
+
+    // ---- hashStream over a synthetic Readable ----
+    var streamDigest = await b.crypto.hashStream(Readable.from([Buffer.from(payload)]));
+    check("hashStream digest matches hashFile",      streamDigest.equals(fileDigest));
+
+    // ---- shake256 produces 64-byte digest by default ----
+    var shakeDigest = await b.crypto.hashStream(Readable.from([Buffer.from(payload)]), "shake256");
+    check("hashStream shake256 → 64 bytes",          shakeDigest.length === 64);
+
+    // ---- Algorithm allowlist rejects md5/sha1/sha256 ----
+    var weakErr;
+    try { await b.crypto.hashStream(Readable.from(["x"]), "md5"); }
+    catch (e) { weakErr = e; }
+    check("hashStream rejects md5",                  weakErr && /unsupported algorithm/.test(weakErr.message));
+
+    var sha1Err;
+    try { await b.crypto.hashFile(tmp, "sha1"); }
+    catch (e) { sha1Err = e; }
+    check("hashFile rejects sha1",                   sha1Err && /unsupported algorithm/.test(sha1Err.message));
+
+    var sha256Err;
+    try { await b.crypto.hashFile(tmp, "sha256"); }
+    catch (e) { sha256Err = e; }
+    check("hashFile rejects sha256",                 sha256Err && /unsupported algorithm/.test(sha256Err.message));
+
+    // ---- Bad arg: empty path ----
+    var badPathErr;
+    try { await b.crypto.hashFile(""); }
+    catch (e) { badPathErr = e; }
+    check("hashFile rejects empty path",             badPathErr instanceof TypeError);
+
+    // ---- Bad arg: non-stream readable ----
+    var badStreamErr;
+    try { await b.crypto.hashStream({ not: "a stream" }); }
+    catch (e) { badStreamErr = e; }
+    check("hashStream rejects non-stream",           badStreamErr instanceof TypeError);
+
+    // ---- Missing file → rejection (not silent default) ----
+    var missingErr;
+    try { await b.crypto.hashFile(tmp + ".does-not-exist"); }
+    catch (e) { missingErr = e; }
+    check("hashFile rejects missing path",           !!missingErr);
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (_e) { /* best-effort cleanup */ }
+  }
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () {
+    console.log("OK — crypto.hashFile / hashStream — " + helpers.getChecks() + " checks");
+  }, function (e) {
+    console.error(e && e.stack || e);
+    process.exit(1);
+  });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/crypto-hpke-pq.test.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * b.crypto.hpke.pq.connolly / .wg — opt-in PQ-HPKE draft wrappers.
+ * Cross-draft substitution refused via info-label binding.
+ */
+
+var helpers = require("../helpers");
+var b = helpers.b;
+var check = helpers.check;
+
+function testConnollyRoundTrip() {
+  var pair = b.crypto.hpke.generateKeyPair();
+  var sealed = b.crypto.hpke.pq.connolly.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "msg",
+    info:            "topic/a",
+    aad:             "context",
+  });
+  check("connolly seal returns enc",        Buffer.isBuffer(sealed.enc));
+  check("connolly seal returns ciphertext", Buffer.isBuffer(sealed.ciphertext));
+
+  var pt = b.crypto.hpke.pq.connolly.open({
+    privateKey: pair.privateKey,
+    enc:        sealed.enc,
+    ciphertext: sealed.ciphertext,
+    info:       "topic/a",
+    aad:        "context",
+  });
+  check("connolly round-trip", pt.toString("utf8") === "msg");
+}
+
+function testWgRoundTrip() {
+  var pair = b.crypto.hpke.generateKeyPair();
+  var sealed = b.crypto.hpke.pq.wg.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "wg msg",
+    info:            "topic/b",
+  });
+  var pt = b.crypto.hpke.pq.wg.open({
+    privateKey: pair.privateKey,
+    enc:        sealed.enc,
+    ciphertext: sealed.ciphertext,
+    info:       "topic/b",
+  });
+  check("wg round-trip", pt.toString("utf8") === "wg msg");
+}
+
+function testCrossDraftRefused() {
+  var pair = b.crypto.hpke.generateKeyPair();
+  var sealedConnolly = b.crypto.hpke.pq.connolly.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "secret",
+    info:            "ctx",
+  });
+  // Attempt to open a connolly envelope with the wg primitive — the
+  // info-label binding diverges so the AEAD tag verify fails.
+  var threw = false;
+  try {
+    b.crypto.hpke.pq.wg.open({
+      privateKey: pair.privateKey,
+      enc:        sealedConnolly.enc,
+      ciphertext: sealedConnolly.ciphertext,
+      info:       "ctx",
+    });
+  } catch (_e) { threw = true; }
+  check("connolly → wg cross-open refused", threw);
+
+  var sealedWg = b.crypto.hpke.pq.wg.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "secret",
+    info:            "ctx",
+  });
+  threw = false;
+  try {
+    b.crypto.hpke.pq.connolly.open({
+      privateKey: pair.privateKey,
+      enc:        sealedWg.enc,
+      ciphertext: sealedWg.ciphertext,
+      info:       "ctx",
+    });
+  } catch (_e) { threw = true; }
+  check("wg → connolly cross-open refused", threw);
+}
+
+function testEmptyInfoEquivalentToOmitted() {
+  var pair = b.crypto.hpke.generateKeyPair();
+  // Seal without info, open with info: "" — MUST round-trip.
+  var sealed = b.crypto.hpke.pq.connolly.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "neutral",
+  });
+  var pt = b.crypto.hpke.pq.connolly.open({
+    privateKey: pair.privateKey,
+    enc:        sealed.enc,
+    ciphertext: sealed.ciphertext,
+    info:       "",
+  });
+  check("empty info round-trips with omitted info", pt.toString("utf8") === "neutral");
+
+  // Reverse: seal with info: "", open without info.
+  var sealed2 = b.crypto.hpke.pq.wg.seal({
+    recipientPubKey: pair.publicKey,
+    plaintext:       "back",
+    info:            "",
+  });
+  var pt2 = b.crypto.hpke.pq.wg.open({
+    privateKey: pair.privateKey,
+    enc:        sealed2.enc,
+    ciphertext: sealed2.ciphertext,
+  });
+  check("omitted info round-trips with empty info on seal", pt2.toString("utf8") === "back");
+}
+
+function testLabelsExported() {
+  check("connolly label exported",
+    typeof b.crypto.hpke.pq.connolly.label === "string" &&
+    b.crypto.hpke.pq.connolly.label.indexOf("connolly") !== -1);
+  check("wg label exported",
+    typeof b.crypto.hpke.pq.wg.label === "string" &&
+    b.crypto.hpke.pq.wg.label.indexOf("hpke-pq") !== -1);
+}
+
+function run() {
+  testConnollyRoundTrip();
+  testWgRoundTrip();
+  testCrossDraftRefused();
+  testEmptyInfoEquivalentToOmitted();
+  testLabelsExported();
+}
+
+if (require.main === module) run();
+module.exports = { run: run };