@blamejs/blamejs-shop 0.0.44

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

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * tracing — OpenTelemetry seam.
+ *
+ * Run standalone: `node test/layer-0-primitives/tracing.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers = require("../helpers");
+var b                = helpers.b;
+var check            = helpers.check;
+var _bodyRes         = helpers._bodyRes;
+var _makeFakeOtelApi = helpers.makeFakeOtelApi;
+
+function testTracingSurface() {
+  check("b.tracing namespace present",      typeof b.tracing === "object");
+  check("b.tracing.create is a function",   typeof b.tracing.create === "function");
+  check("b.tracing.tap is a function",      typeof b.tracing.tap === "function");
+  check("TracingError class",               typeof b.tracing.TracingError === "function");
+  check("TRACEPARENT_RE exposed",           b.tracing.TRACEPARENT_RE instanceof RegExp);
+}
+
+function testTracingTraceparentParse() {
+  var t = b.tracing;
+  var ok = t._parseTraceparent("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01");
+  check("traceparent: parses valid",        ok && ok.traceId === "0af7651916cd43dd8448eb211c80319c");
+  check("traceparent: extracts spanId",     ok.spanId === "b7ad6b7169203331");
+  check("traceparent: rejects bad format",  t._parseTraceparent("malformed") === null);
+  check("traceparent: rejects all-zero traceId",
+        t._parseTraceparent("00-" + "0".repeat(32) + "-b7ad6b7169203331-01") === null);
+  check("traceparent: rejects all-zero spanId",
+        t._parseTraceparent("00-0af7651916cd43dd8448eb211c80319c-" + "0".repeat(16) + "-01") === null);
+  check("traceparent: rejects future version (01)",
+        t._parseTraceparent("01-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01") === null);
+}
+
+function testTracingTraceparentFormat() {
+  var t = b.tracing;
+  var s = t._formatTraceparent("a".repeat(32), "b".repeat(16), "01");
+  check("traceparent: format with explicit flags",
+        s === "00-" + "a".repeat(32) + "-" + "b".repeat(16) + "-01");
+  var d = t._formatTraceparent("a".repeat(32), "b".repeat(16));
+  check("traceparent: default flags = 01",  d.endsWith("-01"));
+}
+
+function testTracingNewIds() {
+  var t = b.tracing;
+  var traceId = t._newTraceId();
+  var spanId = t._newSpanId();
+  check("newTraceId: 32 hex chars",         /^[0-9a-f]{32}$/.test(traceId));
+  check("newSpanId: 16 hex chars",          /^[0-9a-f]{16}$/.test(spanId));
+  var seen = new Set();
+  for (var i = 0; i < 50; i++) seen.add(t._newTraceId());
+  check("newTraceId: 50 calls produce 50 distinct ids", seen.size === 50);
+}
+
+async function testTracingPassthroughSpan() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var ranWith = null;
+  var result = await t.span("test-op", function (span) {
+    ranWith = span;
+    span.setAttribute("k", "v");
+    span.addEvent("hello");
+    return 42;
+  });
+  check("passthrough: span body executes",         result === 42);
+  check("passthrough: span passed to fn",          ranWith && ranWith._isPassthrough === true);
+  t.deactivate();
+}
+
+async function testTracingPassthroughSpanAsync() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var result = await t.span("async-op", async function () {
+    await new Promise(function (r) { setImmediate(r); });
+    return "done";
+  });
+  check("passthrough: async span returns value",   result === "done");
+  t.deactivate();
+}
+
+async function testTracingPassthroughSpanThrows() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var threw = null;
+  try {
+    await t.span("err-op", async function () { throw new Error("boom"); });
+  } catch (e) { threw = e; }
+  check("passthrough: throw propagates",            threw && threw.message === "boom");
+  t.deactivate();
+}
+
+async function testTracingRealSpan() {
+  b.tracing._resetForTest();
+  var fake = _makeFakeOtelApi();
+  b.tracing._setOtelForTest(fake);
+  var t = b.tracing.create();
+  check("isReal: detects OTel installed",          t.isReal() === true);
+  var result = await t.span("real-op", function (span) {
+    span.setAttribute("user_id", "u1");
+    span.addEvent("checkpoint-1");
+    return 7;
+  }, { attributes: { route: "/x" } });
+  check("real span: returns fn value",             result === 7);
+  check("real span: tracer received span name",    fake._spans[0]._name === "real-op");
+  check("real span: attributes set during fn",     fake._spans[0]._attrs.user_id === "u1");
+  check("real span: events captured",              fake._spans[0]._events.indexOf("checkpoint-1") !== -1);
+  check("real span: ended after fn",               fake._spans[0]._ended === true);
+  t.deactivate();
+}
+
+async function testTracingRealSpanThrowRecordsException() {
+  b.tracing._resetForTest();
+  var fake = _makeFakeOtelApi();
+  b.tracing._setOtelForTest(fake);
+  var t = b.tracing.create();
+  var threw = null;
+  try {
+    await t.span("err-op", async function () { throw new Error("kaboom"); });
+  } catch (e) { threw = e; }
+  check("real span: throw propagates",                  threw && threw.message === "kaboom");
+  check("real span: exception recorded",                fake._spans[0]._exceptions.length === 1);
+  check("real span: status code 2 (ERROR)",             fake._spans[0]._status.code === 2);
+  check("real span: still ended after throw",           fake._spans[0]._ended === true);
+  t.deactivate();
+}
+
+async function testTracingCurrentSpanInsideFn() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var seen = null;
+  await t.span("outer", function () {
+    seen = t.currentSpan();
+  });
+  check("currentSpan: returns active passthrough span inside fn",
+        seen && seen._isPassthrough === true);
+  check("currentSpan: null after span ended",  t.currentSpan() === null);
+  t.deactivate();
+}
+
+async function testTracingContextHeaders() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  check("contextHeaders: empty when no active span", Object.keys(t.contextHeaders()).length === 0);
+  var headers = null;
+  await t.span("op", function () { headers = t.contextHeaders(); });
+  check("contextHeaders: traceparent set inside span",
+        typeof headers.traceparent === "string" &&
+        b.tracing.TRACEPARENT_RE.test(headers.traceparent));
+  t.deactivate();
+}
+
+function testTracingExtractContext() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var headers = { traceparent: "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01" };
+  var ctx = t.extractContext(headers);
+  check("extractContext: parses incoming traceparent",
+        ctx && ctx.traceId === "0af7651916cd43dd8448eb211c80319c");
+  check("extractContext: returns null on missing header",
+        t.extractContext({}) === null);
+  check("extractContext: returns null on malformed",
+        t.extractContext({ traceparent: "garbage" }) === null);
+  t.deactivate();
+}
+
+async function testTracingRequestMiddleware() {
+  b.tracing._resetForTest();
+  var fake = _makeFakeOtelApi();
+  b.tracing._setOtelForTest(fake);
+  var t = b.tracing.create();
+  var mw = t.requestMiddleware();
+
+  var EE = require("node:events").EventEmitter;
+  var req = new EE();
+  req.method = "GET";
+  req.url = "/users/123";
+  req.routePattern = "/users/:id";
+  req.headers = {
+    traceparent: "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01",
+  };
+  var res = _bodyRes();
+  await new Promise(function (resolve) {
+    res.on("finish", resolve);
+    mw(req, res, function () {
+      res.writeHead(200);
+      res.end();
+    });
+  });
+  check("requestMiddleware: span name = HTTP method route",
+        fake._spans[0]._name === "HTTP GET /users/:id");
+  check("requestMiddleware: http.method attribute set",
+        fake._spans[0]._attrs["http.method"] === "GET");
+  check("requestMiddleware: http.route attribute set",
+        fake._spans[0]._attrs["http.route"] === "/users/:id");
+  check("requestMiddleware: parent traceparent attribute set",
+        fake._spans[0]._attrs["traceparent.parent"] === "0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331");
+  check("requestMiddleware: http.status_code captured",
+        fake._spans[0]._attrs["http.status_code"] === 200);
+  check("requestMiddleware: span ended",            fake._spans[0]._ended === true);
+  check("requestMiddleware: req.span exposed",      req.span !== undefined);
+  t.deactivate();
+}
+
+async function testTracingTapRoutes() {
+  b.tracing._resetForTest();
+  var fake = _makeFakeOtelApi();
+  b.tracing._setOtelForTest(fake);
+  var t = b.tracing.create();
+  var ran = false;
+  await b.tracing.tap("framework.audit.record", { action: "auth.login" }, function () {
+    ran = true;
+  });
+  check("tap: fn ran",                             ran === true);
+  check("tap: span created with given name",       fake._spans[0]._name === "framework.audit.record");
+  check("tap: attributes propagated",              fake._spans[0]._attrs.action === "auth.login");
+  t.deactivate();
+}
+
+async function testTracingTapNoOpWhenNoRegistry() {
+  b.tracing._resetForTest();
+  var ran = false;
+  var result = await b.tracing.tap("nothing", function () { ran = true; return 99; });
+  check("tap: fn still runs without registry",     ran === true);
+  check("tap: return value preserved",             result === 99);
+}
+
+async function testTracingPassthroughTap() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  var captured = null;
+  await b.tracing.tap("passthru-tap", function (s) { captured = s; });
+  check("passthrough tap: span passed to fn",      captured && captured._isPassthrough === true);
+  t.deactivate();
+}
+
+function testTracingIsReal() {
+  b.tracing._resetForTest();
+  b.tracing._setOtelForTest(null);
+  var t = b.tracing.create();
+  check("isReal: false when no OTel",              t.isReal() === false);
+  t.deactivate();
+}
+
+async function run() {
+  testTracingSurface();
+  testTracingTraceparentParse();
+  testTracingTraceparentFormat();
+  testTracingNewIds();
+  await testTracingPassthroughSpan();
+  await testTracingPassthroughSpanAsync();
+  await testTracingPassthroughSpanThrows();
+  await testTracingRealSpan();
+  await testTracingRealSpanThrowRecordsException();
+  await testTracingCurrentSpanInsideFn();
+  await testTracingContextHeaders();
+  testTracingExtractContext();
+  await testTracingRequestMiddleware();
+  await testTracingTapRoutes();
+  await testTracingTapNoOpWhenNoRegistry();
+  await testTracingPassthroughTap();
+  testTracingIsReal();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e.message); process.exit(1); }
+  );
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * b.uuid — RFC 4122 v4 + RFC 9562 v7 generation, parse/validate.
+ */
+
+var helpers = require("../helpers");
+var b     = helpers.b;
+var check = helpers.check;
+
+function _isHex(s) { return /^[0-9a-f]+$/i.test(s); }
+
+async function run() {
+  // ---- Surface ----
+  check("b.uuid namespace present",       typeof b.uuid === "object");
+  check("b.uuid.v4 is fn",                typeof b.uuid.v4 === "function");
+  check("b.uuid.v7 is fn",                typeof b.uuid.v7 === "function");
+  check("b.uuid.parse is fn",             typeof b.uuid.parse === "function");
+  check("b.uuid.isValid is fn",           typeof b.uuid.isValid === "function");
+
+  // ---- v4 ----
+  var u4 = b.uuid.v4();
+  check("v4 returns canonical 8-4-4-4-12 form",
+        /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(u4));
+  check("v4 sets version nibble to 4",        u4.charAt(14) === "4");
+  check("v4 variant is RFC 4122",             /[89ab]/i.test(u4.charAt(19)));
+  // Two consecutive v4s differ
+  var a4 = b.uuid.v4();
+  var b4 = b.uuid.v4();
+  check("v4 is random across calls",          a4 !== b4);
+
+  // ---- v7 ----
+  var u7 = b.uuid.v7();
+  check("v7 returns canonical 8-4-4-4-12 form",
+        /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(u7));
+  check("v7 sets version nibble to 7",        u7.charAt(14) === "7");
+  check("v7 variant is RFC 4122",             /[89ab]/i.test(u7.charAt(19)));
+
+  // v7 is time-ordered: an earlier `now` produces a UUID that sorts < a later one
+  var early = b.uuid.v7({ now: 1000 });
+  var late  = b.uuid.v7({ now: 2000000 });
+  check("v7 is time-sortable (early < late)", early < late);
+
+  // ms timestamp round-trips through bytes 0-5
+  var fixed = b.uuid.v7({ now: 0x123456789abc });
+  // bytes 0-5 = 12 34 56 78 9a bc → first 12 hex chars (excluding the dashes after 8 + 4)
+  check("v7 timestamp encoded in first 48 bits",
+        fixed.slice(0, 8) + fixed.slice(9, 13) === "123456789abc");
+
+  // ---- parse ----
+  var p4 = b.uuid.parse(u4);
+  check("parse(v4): ok",                      p4.ok === true);
+  check("parse(v4): version = 4",             p4.version === 4);
+  check("parse(v4): bytes is 16-byte Buffer", Buffer.isBuffer(p4.bytes) && p4.bytes.length === 16);
+
+  var p7 = b.uuid.parse(u7);
+  check("parse(v7): version = 7",             p7.version === 7);
+
+  // Bad inputs
+  check("parse(non-string) → ok:false",       b.uuid.parse(42).ok === false);
+  check("parse(empty) → ok:false",            b.uuid.parse("").ok === false);
+  check("parse(too short) → ok:false",        b.uuid.parse("abc").ok === false);
+  check("parse(no dashes) → ok:false",        b.uuid.parse(u4.replace(/-/g, "")).ok === false);
+  // Bad version (0 not valid)
+  var badVer = "12345678-1234-0123-8123-123456789012";
+  check("parse(version 0) → ok:false",        b.uuid.parse(badVer).ok === false);
+  // Bad variant (high two bits 00 instead of 10)
+  var badVar = "12345678-1234-4123-0123-123456789012";
+  check("parse(bad variant) → ok:false",      b.uuid.parse(badVar).ok === false);
+
+  // ---- isValid (loose) ----
+  check("isValid(v4) === true",                b.uuid.isValid(u4) === true);
+  check("isValid(v7) === true",                b.uuid.isValid(u7) === true);
+  check("isValid('not-a-uuid') === false",     b.uuid.isValid("not-a-uuid") === false);
+  check("isValid(uppercase) accepted",         b.uuid.isValid(u4.toUpperCase()) === true);
+  check("isValid(non-string) === false",       b.uuid.isValid(42) === false);
+
+  // Hex-only check on bytes/groups
+  var groups = u4.split("-");
+  check("v4 group lengths 8/4/4/4/12",
+        groups[0].length === 8 && groups[1].length === 4 && groups[2].length === 4 &&
+        groups[3].length === 4 && groups[4].length === 12);
+  check("v4 groups are all hex",
+        groups.every(_isHex));
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(
+    function () { console.log("OK — " + helpers.getChecks() + " checks passed"); },
+    function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }
+  );
+}

package/lib/vendor/blamejs/test/layer-0-primitives/vault-aad.test.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * b.vault.aad — AAD-bound sealed columns.
+ */
+
+var b = require("../..");
+var check = require("../helpers/check").check;
+var fs = require("fs");
+var path = require("path");
+var os  = require("os");
+
+function rejects(label, fn, pattern) {
+  var threw = false; var msg = "";
+  try { fn(); } catch (e) { threw = true; msg = e.message; }
+  check("threw on " + label, threw && (pattern.test ? pattern.test(msg) : msg.indexOf(pattern) !== -1));
+}
+
+async function run() {
+  // ---- module shape ----
+  check("b.vault.aad is object",                 typeof b.vault.aad === "object");
+  check("b.vault.aad.seal is fn",                typeof b.vault.aad.seal === "function");
+  check("b.vault.aad.unseal is fn",              typeof b.vault.aad.unseal === "function");
+  check("b.vault.aad.reseal is fn",              typeof b.vault.aad.reseal === "function");
+  check("b.vault.aad.isAadSealed is fn",         typeof b.vault.aad.isAadSealed === "function");
+  check("b.vault.aad.buildColumnAad is fn",      typeof b.vault.aad.buildColumnAad === "function");
+  check("b.vault.aad.buildContextAad is fn",     typeof b.vault.aad.buildContextAad === "function");
+  check("b.vault.aad.AAD_PREFIX",                b.vault.aad.AAD_PREFIX === "vault.aad:");
+
+  // ---- vault must be initialized ----
+  // Seal before init throws via the vault path.
+  rejects("seal: vault not initialized",
+    function () { b.vault.aad.seal("plaintext", { table: "users", rowId: "u1", column: "email" }); },
+    /vault\.init\(\) must be awaited/);
+
+  // ---- initialize vault on a temp dir ----
+  var tmp = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-vault-aad-"));
+  await b.vault.init({ dataDir: tmp, mode: "plaintext" });
+
+  // ---- buildColumnAad ----
+  var colAad = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-42", column: "email", schemaVersion: "v3",
+  });
+  check("buildColumnAad: table",                 colAad.table === "users");
+  check("buildColumnAad: rowId stringified",     colAad.rowId === "u-42");
+  check("buildColumnAad: column",                colAad.column === "email");
+  check("buildColumnAad: schemaVersion",         colAad.schemaVersion === "v3");
+
+  // schemaVersion default
+  var noVer = b.vault.aad.buildColumnAad({
+    table: "x", rowId: "1", column: "y",
+  });
+  check("buildColumnAad: schemaVersion default",  noVer.schemaVersion === "1");
+
+  // numeric rowId stringified
+  var numRow = b.vault.aad.buildColumnAad({
+    table: "x", rowId: 42, column: "y",
+  });
+  check("buildColumnAad: numeric rowId → string", numRow.rowId === "42");
+
+  rejects("buildColumnAad: missing table",
+    function () { b.vault.aad.buildColumnAad({ rowId: "1", column: "x" }); }, /table/);
+  rejects("buildColumnAad: missing rowId",
+    function () { b.vault.aad.buildColumnAad({ table: "x", column: "y" }); }, /rowId/);
+  rejects("buildColumnAad: missing column",
+    function () { b.vault.aad.buildColumnAad({ table: "x", rowId: "1" }); }, /column/);
+
+  // ---- seal/unseal happy path ----
+  var aad1 = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-1", column: "email",
+  });
+  var sealed = b.vault.aad.seal("alice@example.com", aad1);
+  check("seal: produces aad-prefixed string",     b.vault.aad.isAadSealed(sealed) === true);
+  check("isAadSealed: prefix recognized",         sealed.indexOf("vault.aad:") === 0);
+
+  var unsealed = b.vault.aad.unseal(sealed, aad1);
+  check("unseal: round-trip",                     unsealed === "alice@example.com");
+
+  // ---- AEAD authentication: different AAD breaks decrypt ----
+  var aadOther = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-2", column: "email",       // different rowId
+  });
+  rejects("unseal: different rowId AAD → AEAD mismatch",
+    function () { b.vault.aad.unseal(sealed, aadOther); },
+    /AEAD authentication failed/);
+
+  var aadDifferentColumn = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-1", column: "phone",       // different column
+  });
+  rejects("unseal: different column AAD → AEAD mismatch",
+    function () { b.vault.aad.unseal(sealed, aadDifferentColumn); },
+    /AEAD authentication failed/);
+
+  var aadDifferentTable = b.vault.aad.buildColumnAad({
+    table: "audit", rowId: "u-1", column: "email",       // different table
+  });
+  rejects("unseal: different table AAD → AEAD mismatch",
+    function () { b.vault.aad.unseal(sealed, aadDifferentTable); },
+    /AEAD authentication failed/);
+
+  var aadDifferentVersion = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-1", column: "email", schemaVersion: "v2",
+  });
+  rejects("unseal: different schemaVersion AAD → AEAD mismatch",
+    function () { b.vault.aad.unseal(sealed, aadDifferentVersion); },
+    /AEAD authentication failed/);
+
+  // ---- isAadSealed ----
+  check("isAadSealed: plain string",             b.vault.aad.isAadSealed("plain") === false);
+  check("isAadSealed: null",                     b.vault.aad.isAadSealed(null) === false);
+  check("isAadSealed: number",                   b.vault.aad.isAadSealed(42) === false);
+
+  // ---- buildContextAad ----
+  var contextAad = b.vault.aad.buildContextAad({
+    tenantId: "t-1", purpose: "analytics-export",
+  });
+  check("buildContextAad: tenantId",              contextAad.tenantId === "t-1");
+  check("buildContextAad: purpose",               contextAad.purpose === "analytics-export");
+
+  // null fields stripped
+  var withNull = b.vault.aad.buildContextAad({
+    tenantId: "t-1", purpose: null, missing: undefined, kept: "yes",
+  });
+  check("buildContextAad: null stripped",         withNull.purpose === undefined);
+  check("buildContextAad: undefined stripped",    withNull.missing === undefined);
+  check("buildContextAad: kept retained",         withNull.kept === "yes");
+
+  rejects("buildContextAad: empty obj",
+    function () { b.vault.aad.buildContextAad({}); }, /at least one/);
+  rejects("buildContextAad: array",
+    function () { b.vault.aad.buildContextAad([1, 2]); }, /plain object/);
+
+  // poisoned keys stripped
+  var poisoned = b.vault.aad.buildContextAad({
+    tenantId: "t-1", "__proto__": "evil", "constructor": "evil",
+  });
+  check("buildContextAad: poisoned keys stripped", poisoned.__proto__ === Object.prototype);
+
+  // ---- canonical-form determinism: order-insensitive ----
+  var aadA = { table: "users", rowId: "u-1", column: "email", schemaVersion: "1" };
+  var aadB = { schemaVersion: "1", column: "email", rowId: "u-1", table: "users" };
+  var sealedA = b.vault.aad.seal("data", aadA);
+  var openedB = b.vault.aad.unseal(sealedA, aadB);
+  check("canonical AAD: order-insensitive",      openedB === "data");
+
+  // ---- reseal ----
+  var fromAad = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-1", column: "email",
+  });
+  var toAad = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "u-1", column: "email", schemaVersion: "v2",
+  });
+  var sealedFrom = b.vault.aad.seal("hello", fromAad);
+  var sealedTo = b.vault.aad.reseal(sealedFrom, fromAad, toAad);
+  check("reseal: produces new aad-sealed value",  b.vault.aad.isAadSealed(sealedTo));
+  check("reseal: decrypts with new AAD",          b.vault.aad.unseal(sealedTo, toAad) === "hello");
+  rejects("reseal: old AAD no longer works",
+    function () { b.vault.aad.unseal(sealedTo, fromAad); }, /AEAD/);
+
+  // reseal with bad source AAD throws
+  rejects("reseal: wrong source AAD",
+    function () { b.vault.aad.reseal(sealedFrom, toAad, fromAad); }, /AEAD/);
+
+  // ---- error shapes ----
+  rejects("seal: null plaintext",
+    function () { b.vault.aad.seal(null, fromAad); }, /required/);
+  rejects("seal: empty string",
+    function () { b.vault.aad.seal("", fromAad); }, /non-empty/);
+  rejects("seal: bad AAD shape",
+    function () { b.vault.aad.seal("hi", null); }, /must be a plain object/);
+  rejects("seal: empty AAD",
+    function () { b.vault.aad.seal("hi", {}); }, /at least one/);
+  rejects("seal: array AAD",
+    function () { b.vault.aad.seal("hi", [1, 2]); }, /plain object/);
+
+  // double-seal refused
+  rejects("seal: refuses double-seal",
+    function () { b.vault.aad.seal(sealed, fromAad); }, /already.*sealed/i);
+
+  // ---- unseal error shapes ----
+  rejects("unseal: not aad-sealed",
+    function () { b.vault.aad.unseal("plaintext", fromAad); }, /not AAD-sealed/);
+  rejects("unseal: null value",
+    function () { b.vault.aad.unseal(null, fromAad); }, /non-empty string/);
+  rejects("unseal: corrupted base64",
+    function () { b.vault.aad.unseal("vault.aad:###not-base64###", fromAad); }, /AEAD authentication failed/);
+  rejects("unseal: tampered ciphertext",
+    function () {
+      var s = b.vault.aad.seal("data", fromAad);
+      var b64 = s.slice("vault.aad:".length);
+      var buf = Buffer.from(b64, "base64");
+      buf[buf.length - 1] = buf[buf.length - 1] ^ 0xFF;       // allow:raw-byte-literal — flip tag byte
+      b.vault.aad.unseal("vault.aad:" + buf.toString("base64"), fromAad);
+    },
+    /AEAD authentication failed/);
+
+  // ---- AAD with non-string / non-number / non-boolean values ----
+  rejects("seal: object value in AAD",
+    function () {
+      b.vault.aad.seal("hi", { table: "u", rowId: { nested: "obj" } });
+    },
+    /must be string \/ number \/ boolean/);
+  rejects("seal: array value in AAD",
+    function () {
+      b.vault.aad.seal("hi", { table: "u", rowId: [1, 2] });
+    },
+    /must be string \/ number \/ boolean/);
+
+  // boolean value accepted
+  var boolAad = { table: "users", rowId: "1", column: "active", flag: true };
+  var sealedBool = b.vault.aad.seal("data", boolAad);
+  check("seal: boolean AAD field",                b.vault.aad.unseal(sealedBool, boolAad) === "data");
+
+  // numeric value accepted
+  var numAad = { table: "users", rowId: 42, column: "x" };
+  var sealedNum = b.vault.aad.seal("hello", numAad);
+  check("seal: numeric AAD field",                b.vault.aad.unseal(sealedNum, numAad) === "hello");
+
+  // ---- copy-paste-attack scenario ----
+  // Operator seals two distinct rows' values. Attacker swaps the
+  // ciphertexts. Both unseals should fail.
+  var aliceAad = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "alice", column: "phone",
+  });
+  var bobAad = b.vault.aad.buildColumnAad({
+    table: "users", rowId: "bob", column: "phone",
+  });
+  var aliceSealed = b.vault.aad.seal("+1-555-0101", aliceAad);
+  var bobSealed   = b.vault.aad.seal("+1-555-0202", bobAad);
+
+  // Attacker stores Alice's sealed value in Bob's row
+  rejects("copy-paste: Alice → Bob fails",
+    function () { b.vault.aad.unseal(aliceSealed, bobAad); }, /AEAD/);
+  rejects("copy-paste: Bob → Alice fails",
+    function () { b.vault.aad.unseal(bobSealed, aliceAad); }, /AEAD/);
+  // But each row's own seal still works
+  check("non-attack: Alice's own value works",   b.vault.aad.unseal(aliceSealed, aliceAad) === "+1-555-0101");
+  check("non-attack: Bob's own value works",     b.vault.aad.unseal(bobSealed, bobAad) === "+1-555-0202");
+
+  // ---- nonce uniqueness — two seals of same plaintext + AAD differ ----
+  var s1 = b.vault.aad.seal("identical", aliceAad);
+  var s2 = b.vault.aad.seal("identical", aliceAad);
+  check("seal: non-deterministic (nonce uniqueness)", s1 !== s2);
+  // both decrypt correctly
+  check("seal: both nonces decrypt",             b.vault.aad.unseal(s1, aliceAad) === "identical");
+  check("seal: both nonces decrypt (s2)",        b.vault.aad.unseal(s2, aliceAad) === "identical");
+
+  // ---- AAD field name = poisoned key refused ----
+  rejects("seal: __proto__ field name",
+    function () {
+      var evil = {};
+      evil["__proto__"] = "x";
+      evil.table = "u";
+      // Object.keys won't return __proto__ from a literal, so we need
+      // to inject it directly.
+      Object.defineProperty(evil, "__proto__",
+        { value: "x", enumerable: true, configurable: true });
+      b.vault.aad.seal("hi", evil);
+    },
+    /forbidden|poisoned|table|must be a plain object/);
+
+  // ---- vault rotation breaks prior seals (per design) ----
+  // Skip this — would re-init the vault and conflict with concurrent tests
+
+  // b.vault.getDerivedHashSalt — D-H1 per-deployment salt for
+  // crypto-field derivedHashes. Just check the surface here; the
+  // round-trip is exercised through the existing crypto-field tests.
+  check("b.vault.getDerivedHashSalt is fn",
+    typeof b.vault.getDerivedHashSalt === "function");
+
+  console.log("OK — vault-aad tests");
+}
+
+module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () { process.exit(0); })
+       .catch(function (err) { console.error(err); process.exit(1); });
+}