@blamejs/blamejs-shop 0.1.34 → 0.1.36

package/lib/vendor/blamejs/release-notes/v0.13.3.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.3",
+  "date": "2026-05-26",
+  "headline": "`b.crypto.xwing` — X-Wing hybrid post-quantum KEM",
+  "summary": "b.crypto.xwing adds the X-Wing hybrid key-encapsulation mechanism (draft-connolly-cfrg-xwing-kem): it runs ML-KEM-768 and X25519 side by side and binds their shared secrets with SHA3-256, so an encapsulated key stays secure as long as either ML-KEM-768 or X25519 holds. That is the conservative shape for moving off classical ECDH today — a harvest-now-decrypt-later attacker must break the lattice KEM, and a hypothetical ML-KEM break still leaves X25519 standing. keygen() produces a 32-byte decapsulation seed and a 1216-byte public key; encapsulate(publicKey) returns a 1120-byte ciphertext and a 32-byte shared secret; decapsulate(secretKey, ciphertext) recovers it. The X-Wing combiner is frozen, but its specification is still an IETF Internet-Draft, so this primitive is marked experimental and sits beside the existing pre-RFC post-quantum HPKE drafts; it composes the framework's vendored ML-KEM-768 and X25519 with SHA3 and adds no new cryptographic core. The combiner is known-answer-tested byte-for-byte against the draft's definition.",
+  "sections": [
+    {
+      "heading": "Added",
+      "items": [
+        {
+          "title": "`b.crypto.xwing` — X-Wing hybrid PQ/T KEM (experimental)",
+          "body": "`keygen(seed?)` → `{ publicKey (1216 B), secretKey (32-byte seed) }`; `encapsulate(publicKey, eseed?)` → `{ ciphertext (1120 B), sharedSecret (32 B) }`; `decapsulate(secretKey, ciphertext)` → the 32-byte shared secret. Both `keygen` and `encapsulate` accept an optional seed for deterministic operation. The combiner — `SHA3-256(ssMLKEM ‖ ssX25519 ‖ ctX25519 ‖ pkX25519 ‖ label)` — is exposed as `combiner` for advanced use. Marked `experimental` while draft-connolly-cfrg-xwing-kem remains an Internet-Draft; the algorithm itself is frozen."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.4.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.4",
+  "date": "2026-05-26",
+  "headline": "`b.crdt` — conflict-free replicated data types",
+  "summary": "b.crdt adds state-based Conflict-free Replicated Data Types: data structures that independent replicas update without coordination and still converge to the same value once they have exchanged state. Each type's merge is a join over a semilattice — commutative, associative, and idempotent — so replicas can merge in any order, any number of times, and agree, which makes these the substrate for active/active cluster state, offline-first clients that reconcile on reconnect, and eventually-consistent counters, sets, and maps. The release ships the full state-based family: grow-only and positive-negative counters (gCounter / pnCounter), grow-only, two-phase, and observed-remove sets (gSet / twoPSet / orSet), a last-write-wins register (lwwRegister), and an observed-remove map (orMap). Every type exposes the same contract — local mutators, merge(other) that returns a converged instance without mutating either operand, value() for the materialized value, and state() / fromState() for a JSON-serializable form to snapshot via b.archive or b.backup or ship to a peer — and carries a replicaId so per-replica contributions stay distinct.",
+  "sections": [
+    {
+      "heading": "Added",
+      "items": [
+        {
+          "title": "`b.crdt` — state-based CvRDT counters, sets, register, and map",
+          "body": "`b.crdt.gCounter` / `pnCounter` (grow-only and increment/decrement counters), `b.crdt.gSet` / `twoPSet` / `orSet` (grow-only, two-phase, and observed-remove sets — `orSet` supports re-add and resolves a concurrent add-vs-remove as add-wins), `b.crdt.lwwRegister` (last-write-wins with a deterministic replicaId tie-break), and `b.crdt.orMap` (observed-remove keys with last-write-wins values). Each exposes `merge` / `value` / `state` / `fromState` and converges by the CvRDT laws. `orSet` and `orMap` accept `tombstoneRetention` to bound tombstone memory against a remove flood."
+        }
+      ]
+    }
+  ],
+  "outOfScope": [
+    "Operation-based sequence CRDTs (RGA) — a different formal class (CmRDT) requiring a causal-delivery channel; ships when collaborative-text / ordered-list editing is needed.",
+    "Delta-state mutators — a bandwidth optimization over full-state merge; ships under large-state replication pressure.",
+    "The event-bus replicator for live multi-node auto-sync — the state-based types merge manually standalone; ships when live multi-node synchronization is wired, together with the causal-delivery option and its detector."
+  ]
+}

package/lib/vendor/blamejs/release-notes/v0.13.5.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "../scripts/release-notes-schema.json",
+  "version": "0.13.5",
+  "date": "2026-05-26",
+  "headline": "`b.ai.aedtBiasAudit` — NYC Local Law 144 bias audit",
+  "summary": "b.ai.aedtBiasAudit computes the bias-audit figures New York City Local Law 144 requires before an Automated Employment Decision Tool may screen candidates (NYC Admin. Code §20-870 et seq.; DCWP rules 6 RCNY §5-300). Given the per-category counts an independent auditor collected — selected/total for a pass-fail tool, or scored-above-the-overall-median/total for a continuous-score tool — it returns the selection (or scoring) rate, the impact ratio (each group's rate divided by the most-selected group's rate), and an adverse-impact flag (impact ratio below the EEOC four-fifths threshold of 0.8) for every group, across the sex, race/ethnicity, and intersectional dimensions, plus the most-selected group per dimension and an overall flag. Categories under 2% of the audited data are marked excluded per DCWP discretion. It is a pure calculation that produces exactly the figures the annual published summary must contain — the law mandates the calculation, not any particular remediation. The relevant compliance postures (nyc-ll144, and ca-tfaia for California SB 53) were already in the catalog.",
+  "sections": [
+    {
+      "heading": "Added",
+      "items": [
+        {
+          "title": "`b.ai.aedtBiasAudit` — Local Law 144 selection/scoring rates and four-fifths impact ratios",
+          "body": "`b.ai.aedtBiasAudit({ type, metadata, categories, minCategoryShare? })` where `type` is `\"selection\"` (group entries `{ selected, total }`) or `\"scoring\"` (`{ scoredAboveMedian, total }`). Returns per-group rate, impact ratio, and `adverseImpact` flag across the `sex`, `raceEthnicity`, and `intersectional` dimensions, plus the most-selected group per dimension and an `anyAdverseImpact` summary. Categories below `minCategoryShare` (2% default) are excluded from the impact-ratio basis. Throws `AedtBiasAuditError` on malformed input."
+        }
+      ]
+    }
+  ]
+}

package/lib/vendor/blamejs/test/layer-0-primitives/ai-aedt-bias-audit.test.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Layer 0 — b.ai.aedtBiasAudit (NYC Local Law 144 AEDT bias audit).
+ *
+ * Oracle: the EEOC four-fifths rule and the DCWP §5-300 impact-ratio formula.
+ * The canonical worked example — a tool passing 60% of men and 42% of women —
+ * yields an impact ratio of 42/60 = 0.70 for women, below the 0.8 threshold.
+ * Boundary, scoring-rate, intersectional, sub-2% exclusion, and the
+ * most-selected basis are each asserted against the formula.
+ */
+
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+function code(fn) { try { fn(); return "NO-THROW"; } catch (e) { return e.code; } }
+function row(report, dim, cat) { return report.results[dim].filter(function (r) { return r.category === cat; })[0]; }
+
+var MD = { tool: "ResumeRanker v3", auditor: "Acme Audit LLC", auditDate: "2026-05-26" };
+
+function testSurface() {
+  check("b.ai.aedtBiasAudit is a function", typeof b.ai.aedtBiasAudit === "function");
+  check("b.ai.aedtBiasAudit.FOUR_FIFTHS is 0.8", b.ai.aedtBiasAudit.FOUR_FIFTHS === 0.8);
+  check("b.ai.aedtBiasAudit.AedtBiasAuditError is a class", typeof b.ai.aedtBiasAudit.AedtBiasAuditError === "function");
+}
+
+function testFourFifthsWorkedExample() {
+  var r = b.ai.aedtBiasAudit({
+    type: "selection",
+    metadata: MD,
+    categories: { sex: { Male: { selected: 60, total: 100 }, Female: { selected: 42, total: 100 } } },
+  });
+  var f = row(r, "sex", "Female"), m = row(r, "sex", "Male");
+  check("Female selection rate 0.42", f.rate === 0.42);
+  check("Female impact ratio 0.70 (42/60)", Math.abs(f.impactRatio - 0.7) < 1e-9);
+  check("Female flagged adverse (< 0.8)", f.adverseImpact === true);
+  check("Male is the most-selected (ratio 1)", m.impactRatio === 1 && m.adverseImpact === false);
+  check("most-selected sex group is Male", r.summary.mostSelected.sex === "Male");
+  check("anyAdverseImpact true", r.summary.anyAdverseImpact === true);
+  check("adverseImpactGroups names Female", r.summary.adverseImpactGroups.length === 1 && r.summary.adverseImpactGroups[0].category === "Female");
+  check("metadata echoed", r.metadata.tool === MD.tool && r.metadata.auditor === MD.auditor && r.metadata.distributionDate === null);
+}
+
+function testFourFifthsBoundary() {
+  // Exactly 0.80 is NOT adverse (strictly-less-than threshold); 0.79 is.
+  var at = b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { X: { selected: 100, total: 100 }, Y: { selected: 80, total: 100 } } } });
+  check("impact ratio exactly 0.80 is not adverse", row(at, "sex", "Y").adverseImpact === false);
+  var below = b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { X: { selected: 100, total: 100 }, Y: { selected: 79, total: 100 } } } });
+  check("impact ratio 0.79 is adverse", row(below, "sex", "Y").adverseImpact === true);
+}
+
+function testScoringRate() {
+  // Scoring tools: rate = scored-above-overall-median / total.
+  var r = b.ai.aedtBiasAudit({ type: "scoring", metadata: MD, categories: { sex: { M: { scoredAboveMedian: 50, total: 100 }, F: { scoredAboveMedian: 30, total: 100 } } } });
+  check("scoring rate F 0.30", row(r, "sex", "F").rate === 0.3);
+  check("scoring impact ratio F 0.60 (30/50)", Math.abs(row(r, "sex", "F").impactRatio - 0.6) < 1e-9);
+}
+
+function testIntersectionalAndRace() {
+  var r = b.ai.aedtBiasAudit({
+    type: "selection",
+    metadata: MD,
+    categories: {
+      raceEthnicity: { "White": { selected: 80, total: 100 }, "Black or African American": { selected: 48, total: 100 } },
+      intersectional: { "Male - White": { selected: 90, total: 100 }, "Female - Black or African American": { selected: 45, total: 100 } },
+    },
+  });
+  check("race dimension computed", row(r, "raceEthnicity", "Black or African American").impactRatio === 0.6);
+  check("intersectional dimension computed", row(r, "intersectional", "Female - Black or African American").impactRatio === 0.5);
+  check("intersectional adverse flagged", row(r, "intersectional", "Female - Black or African American").adverseImpact === true);
+}
+
+function testSubTwoPercentExclusion() {
+  var r = b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { Big: { selected: 90, total: 1000 }, Tiny: { selected: 0, total: 10 } } } });
+  check("sub-2% category excluded", row(r, "sex", "Tiny").excluded === true);
+  check("excluded category has null impact ratio", row(r, "sex", "Tiny").impactRatio === null);
+  check("excluded category not flagged adverse", row(r, "sex", "Tiny").adverseImpact === false);
+  // A higher minCategoryShare excludes more.
+  var r2 = b.ai.aedtBiasAudit({ type: "selection", metadata: MD, minCategoryShare: 0, categories: { sex: { Big: { selected: 90, total: 1000 }, Tiny: { selected: 0, total: 10 } } } });
+  check("minCategoryShare 0 includes Tiny", row(r2, "sex", "Tiny").excluded === false);
+}
+
+function testErrors() {
+  check("bad type throws",        code(function () { b.ai.aedtBiasAudit({ type: "x", metadata: MD, categories: { sex: { M: { selected: 1, total: 1 } } } }); }) === "aedt/bad-type");
+  check("missing metadata throws", code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: {}, categories: { sex: { M: { selected: 1, total: 1 } } } }); }) === "aedt/bad-metadata");
+  check("no categories throws",    code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: {} }); }) === "aedt/no-categories");
+  check("selected > total throws", code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { M: { selected: 5, total: 2 } } } }); }) === "aedt/bad-count");
+  check("negative count throws",   code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { M: { selected: -1, total: 2 } } } }); }) === "aedt/bad-count");
+  check("bad minCategoryShare throws", code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, minCategoryShare: 1, categories: { sex: { M: { selected: 1, total: 1 } } } }); }) === "aedt/bad-share");
+  // A typoed/unknown option must surface as AedtBiasAuditError (not a generic
+  // Error from validateOpts), so e.code / instanceof handling is reliable.
+  check("unknown opt throws aedt/bad-opts", code(function () { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { M: { selected: 1, total: 1 } } }, minCategoryshare: 0.01 }); }) === "aedt/bad-opts");
+  var threw = null;
+  try { b.ai.aedtBiasAudit({ type: "selection", metadata: MD, categories: { sex: { M: { selected: 1, total: 1 } } }, bogus: 1 }); } catch (e) { threw = e; }
+  check("unknown opt error is an AedtBiasAuditError", threw instanceof b.ai.aedtBiasAudit.AedtBiasAuditError);
+}
+
+async function run() {
+  testSurface();
+  testFourFifthsWorkedExample();
+  testFourFifthsBoundary();
+  testScoringRate();
+  testIntersectionalAndRace();
+  testSubTwoPercentExclusion();
+  testErrors();
+}
+module.exports = { run: run };
+if (require.main === module) { run().then(function () { console.log("[ai-aedt-bias-audit] 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/crdt.test.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Layer 0 — b.crdt (state-based CvRDTs).
+ *
+ * Oracle: the CRDT correctness laws themselves. A state-based CvRDT's merge is
+ * a join over a semilattice, so for every type merge must be commutative,
+ * associative, and idempotent, and two replicas that apply concurrent ops then
+ * merge must converge to the same value. Those laws ARE the specification
+ * (Shapiro et al.); each is asserted below alongside worked examples.
+ */
+
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+var crdt = b.crdt;
+function code(fn) { try { fn(); return "NO-THROW"; } catch (e) { return e.code; } }
+function val(c) { return JSON.stringify(c.value()); }
+
+// Assert the three merge laws for a type, given three instances carrying
+// concurrent (disjoint-replica) ops.
+function laws(label, a, c, d) {
+  check(label + ": commutative", val(a.merge(c)) === val(c.merge(a)));
+  check(label + ": associative", val(a.merge(c).merge(d)) === val(a.merge(c.merge(d))));
+  check(label + ": idempotent",  val(a.merge(a)) === val(a));
+  // Convergence: cross-merge of two replicas lands on one value both ways.
+  check(label + ": converges",   val(a.merge(c)) === val(c.merge(a)));
+}
+
+function testSurface() {
+  // Reference each primitive by its full b.crdt.* path (coverage gate).
+  check("b.crdt.gCounter is a factory",    typeof b.crdt.gCounter === "function" && typeof b.crdt.gCounter.fromState === "function");
+  check("b.crdt.pnCounter is a factory",   typeof b.crdt.pnCounter === "function" && typeof b.crdt.pnCounter.fromState === "function");
+  check("b.crdt.gSet is a factory",        typeof b.crdt.gSet === "function" && typeof b.crdt.gSet.fromState === "function");
+  check("b.crdt.twoPSet is a factory",     typeof b.crdt.twoPSet === "function" && typeof b.crdt.twoPSet.fromState === "function");
+  check("b.crdt.orSet is a factory",       typeof b.crdt.orSet === "function" && typeof b.crdt.orSet.fromState === "function");
+  check("b.crdt.lwwRegister is a factory", typeof b.crdt.lwwRegister === "function" && typeof b.crdt.lwwRegister.fromState === "function");
+  check("b.crdt.orMap is a factory",       typeof b.crdt.orMap === "function" && typeof b.crdt.orMap.fromState === "function");
+  check("b.crdt.CrdtError is a class",     typeof b.crdt.CrdtError === "function");
+}
+
+function testGCounter() {
+  var a = crdt.gCounter({ replicaId: "a" }).inc(3);
+  var c = crdt.gCounter({ replicaId: "c" }).inc(5);
+  var d = crdt.gCounter({ replicaId: "d" }).inc(1);
+  check("gCounter sum across replicas", a.merge(c).value() === 8);
+  laws("gCounter", a, c, d);
+  check("gCounter inc default is 1", crdt.gCounter({ replicaId: "a" }).inc().value() === 1);
+  check("gCounter rejects negative inc", code(function () { crdt.gCounter().inc(-1); }) === "crdt/bad-value");
+}
+
+function testPNCounter() {
+  var a = crdt.pnCounter({ replicaId: "a" }).inc(5).dec(2);
+  var c = crdt.pnCounter({ replicaId: "c" }).inc(1);
+  var d = crdt.pnCounter({ replicaId: "d" }).dec(3);
+  check("pnCounter value", a.value() === 3);
+  check("pnCounter merged value", a.merge(c).merge(d).value() === 1);
+  laws("pnCounter", a, c, d);
+}
+
+function testGSet() {
+  var a = crdt.gSet({ replicaId: "a" }).add("x").add("y");
+  var c = crdt.gSet({ replicaId: "c" }).add("z");
+  var d = crdt.gSet({ replicaId: "d" }).add("x");
+  check("gSet union", val(a.merge(c)) === JSON.stringify(["x", "y", "z"]));
+  check("gSet has", a.has("x") && !a.has("q"));
+  check("gSet supports structured elements", crdt.gSet().add({ k: 1 }).has({ k: 1 }));
+  laws("gSet", a, c, d);
+  // value() order must converge for structured elements regardless of merge
+  // order (sorted by the encoded key, not the decoded value).
+  var s1 = crdt.gSet().add({ id: 2 }).add({ id: 1 });
+  var s2 = crdt.gSet().add({ id: 3 });
+  check("gSet structured-element value order converges", JSON.stringify(s1.merge(s2).value()) === JSON.stringify(s2.merge(s1).value()));
+}
+
+function testTwoPSet() {
+  var s = crdt.twoPSet().add("a").add("b").remove("a");
+  check("twoPSet remove", val(s) === JSON.stringify(["b"]));
+  check("twoPSet remove-wins (no re-add)", !s.add("a").has("a"));
+  var a = crdt.twoPSet({ replicaId: "a" }).add("x").remove("x");
+  var c = crdt.twoPSet({ replicaId: "c" }).add("y");
+  var d = crdt.twoPSet({ replicaId: "d" }).add("z");
+  laws("twoPSet", a, c, d);
+}
+
+function testORSet() {
+  // Concurrent re-add survives a remove that did not observe it.
+  var a = crdt.orSet({ replicaId: "a" }).add("x").add("y");
+  var c = crdt.orSet.fromState(a.state(), { replicaId: "c" });
+  a.remove("x");
+  c.add("x");
+  check("orSet concurrent re-add survives remove", a.merge(c).value().indexOf("x") !== -1);
+  // A remove that observed the add wins.
+  var s = crdt.orSet().add("z");
+  check("orSet observed remove drops element", s.remove("z").value().indexOf("z") === -1);
+  laws("orSet", crdt.orSet({ replicaId: "a" }).add("p"), crdt.orSet({ replicaId: "c" }).add("q"), crdt.orSet({ replicaId: "d" }).add("r"));
+  // tombstoneRetention cap is accepted and bounds the tombstone set.
+  var capped = crdt.orSet({ replicaId: "a", tombstoneRetention: 2 });
+  capped.add("1").add("2").add("3").remove("1").remove("2").remove("3");
+  check("orSet tombstoneRetention bounds the set", capped.state().tombstones.length <= 2);
+  check("orSet rejects bad tombstoneRetention", code(function () { crdt.orSet({ tombstoneRetention: -1 }); }) === "crdt/bad-value");
+}
+
+function testLWWRegister() {
+  var a = crdt.lwwRegister({ replicaId: "a" }).set("first", 1);
+  var c = crdt.lwwRegister({ replicaId: "c" }).set("second", 2);
+  check("lwwRegister higher ts wins", a.merge(c).value() === "second");
+  // Tie-break by replicaId (deterministic).
+  var r1 = crdt.lwwRegister({ replicaId: "a" }).set("a", 100);
+  var r2 = crdt.lwwRegister({ replicaId: "c" }).set("c", 100);
+  check("lwwRegister tie-break by replicaId", r1.merge(r2).value() === "c" && r2.merge(r1).value() === "c");
+  laws("lwwRegister",
+    crdt.lwwRegister({ replicaId: "a" }).set("x", 5),
+    crdt.lwwRegister({ replicaId: "c" }).set("y", 9),
+    crdt.lwwRegister({ replicaId: "d" }).set("z", 3));
+}
+
+function testORMap() {
+  var a = crdt.orMap({ replicaId: "a" }).set("k1", "v1", 10);
+  var c = crdt.orMap({ replicaId: "c" }).set("k1", "v2", 20).set("k2", "x", 5);
+  var merged = a.merge(c);
+  check("orMap concurrent key write resolves LWW", merged.get("k1") === "v2");
+  check("orMap disjoint keys both present", merged.has("k2") && val(merged) === JSON.stringify({ k1: "v2", k2: "x" }));
+  check("orMap commutative", val(a.merge(c)) === val(c.merge(a)));
+  // Remove a key, then converge.
+  var p = crdt.orMap.fromState(merged.state(), { replicaId: "a" }).remove("k2");
+  check("orMap remove converges", val(p.merge(merged)) === JSON.stringify({ k1: "v2" }));
+  check("orMap rejects non-string key", code(function () { crdt.orMap().set(5, "v"); }) === "crdt/bad-key");
+  // Removing a key clears its register, so a re-add starts clean — a later set
+  // with a lower timestamp than the pre-remove value still wins on this replica.
+  var rr = crdt.orMap({ replicaId: "a" }).set("k", "old", 100);
+  rr.remove("k");
+  rr.set("k", "new", 50);   // lower ts than the removed "old"@100
+  check("orMap remove clears register so re-add wins", rr.get("k") === "new");
+  check("orMap re-add appears in value", JSON.stringify(rr.value()) === JSON.stringify({ k: "new" }));
+}
+
+function testStateRoundTrip() {
+  ["gCounter", "pnCounter", "gSet", "twoPSet", "orSet", "lwwRegister", "orMap"].forEach(function (t) {
+    var inst = crdt[t]({ replicaId: "a" });
+    var s = inst.state();
+    check(t + ": fromState round-trips", JSON.stringify(crdt[t].fromState(s, { replicaId: "a" }).state()) === JSON.stringify(s));
+    check(t + ": fromState rejects a mismatched type", code(function () { crdt[t].fromState({ type: "WRONG" }); }) === "crdt/type-mismatch");
+  });
+}
+
+async function run() {
+  testSurface();
+  testGCounter();
+  testPNCounter();
+  testGSet();
+  testTwoPSet();
+  testORSet();
+  testLWWRegister();
+  testORMap();
+  testStateRoundTrip();
+}
+module.exports = { run: run };
+if (require.main === module) { run().then(function () { console.log("[crdt] 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/crypto-xwing.test.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Layer 0 — b.crypto.xwing (X-Wing hybrid PQ/T KEM, draft-connolly-cfrg-xwing-kem).
+ *
+ * Oracle. The X-Wing-specific contribution is the combiner — SHA3-256 over a
+ * fixed concatenation plus a fixed label — so that is known-answer-tested
+ * byte-for-byte against an independent SHA3-256. The ML-KEM-768 and X25519
+ * halves are pre-validated vendored primitives; the composition is checked by
+ * full encaps → decaps agreement, by deterministic reproducibility from fixed
+ * seeds (regression-anchored to pinned digests), and by implicit-rejection
+ * behaviour on a tampered ciphertext.
+ */
+
+var nodeCrypto = require("crypto");
+var b = require("../../index");
+var helpers = require("../helpers");
+var check = helpers.check;
+function code(fn) { try { fn(); return "NO-THROW"; } catch (e) { return e.code; } }
+
+var x = b.crypto.xwing;
+
+function testSurface() {
+  check("xwing.keygen is fn",       typeof x.keygen === "function");
+  check("xwing.encapsulate is fn",  typeof x.encapsulate === "function");
+  check("xwing.decapsulate is fn",  typeof x.decapsulate === "function");
+  check("xwing.combiner is fn",     typeof x.combiner === "function");
+  check("xwing.NAME is X-Wing",     x.NAME === "X-Wing");
+  check("xwing.XWingError is class", typeof x.XWingError === "function");
+  check("SIZES pk 1216",  x.SIZES.publicKey === 1216);
+  check("SIZES ct 1120",  x.SIZES.ciphertext === 1120);
+  check("SIZES sk 32",    x.SIZES.secretKey === 32);
+  check("SIZES ss 32",    x.SIZES.sharedSecret === 32);
+}
+
+function testCombinerKAT() {
+  // Byte-exact against the draft: SHA3-256(ssM ‖ ssX ‖ ctX ‖ pkX ‖ label),
+  // label = the six bytes 5c2e2f2f5e5c ("\./" "/^\").
+  var ssM = Buffer.alloc(32, 0x11), ssX = Buffer.alloc(32, 0x22),
+      ctX = Buffer.alloc(32, 0x33), pkX = Buffer.alloc(32, 0x44);
+  var ref = nodeCrypto.createHash("sha3-256")
+    .update(Buffer.concat([ssM, ssX, ctX, pkX, Buffer.from("5c2e2f2f5e5c", "hex")])).digest();
+  check("combiner matches independent SHA3-256 + label byte-for-byte", x.combiner(ssM, ssX, ctX, pkX).equals(ref));
+  // Order matters: swapping two inputs changes the output.
+  check("combiner is order-sensitive", !x.combiner(ssX, ssM, ctX, pkX).equals(ref));
+  check("combiner rejects a short input", code(function () { x.combiner(Buffer.alloc(31), ssX, ctX, pkX); }) === "xwing/bad-input");
+}
+
+function testSizes() {
+  var kp = x.keygen();
+  check("public key is 1216 bytes", kp.publicKey.length === 1216);
+  check("secret key (seed) is 32 bytes", kp.secretKey.length === 32);
+  var enc = x.encapsulate(kp.publicKey);
+  check("ciphertext is 1120 bytes", enc.ciphertext.length === 1120);
+  check("shared secret is 32 bytes", enc.sharedSecret.length === 32);
+}
+
+function testRoundTrip() {
+  for (var i = 0; i < 5; i++) {
+    var kp = x.keygen();
+    var enc = x.encapsulate(kp.publicKey);
+    var ss = x.decapsulate(kp.secretKey, enc.ciphertext);
+    check("round-trip " + i + ": decaps recovers the encaps shared secret", ss.equals(enc.sharedSecret));
+  }
+}
+
+function testDeterminism() {
+  var seed = Buffer.alloc(32, 1);
+  check("keygen(seed) is deterministic", x.keygen(seed).publicKey.equals(x.keygen(seed).publicKey));
+  var pk = x.keygen(seed).publicKey;
+  // Distinct eseed halves so the value depends on the draft's split order
+  // (eseed[0:32] = ML-KEM coins, eseed[32:64] = X25519 ephemeral).
+  var eseed = Buffer.concat([Buffer.alloc(32, 2), Buffer.alloc(32, 3)]);
+  var a = x.encapsulate(pk, eseed), c2 = x.encapsulate(pk, eseed);
+  check("encapsulate(pk, eseed) is deterministic", a.ciphertext.equals(c2.ciphertext) && a.sharedSecret.equals(c2.sharedSecret));
+  check("deterministic encaps round-trips", x.decapsulate(seed, a.ciphertext).equals(a.sharedSecret));
+
+  // Regression anchors: pinned digests of the full deterministic flow. A change
+  // to the combiner, the seed expansion, the eseed split order, or the wire
+  // framing breaks these.
+  check("keygen(0x01) public key digest is stable",
+    nodeCrypto.createHash("sha3-256").update(pk).digest("hex") === "60068c4c0bfc7421bb1cb4a4202bf0ef75ee27e61bf2f6b08780869485cc736a");
+  check("deterministic ciphertext digest is stable",
+    nodeCrypto.createHash("sha3-256").update(a.ciphertext).digest("hex") === "1422e82c4307fcb8117b28ceaf686241cbe48d1a5546e05cd1aa7401d5fc2624");
+  check("deterministic shared secret is stable",
+    a.sharedSecret.toString("hex") === "356f5611bb146e8baf7fa61410552a9c724a170b8a0d4e742fac19161d8fdf4a");
+}
+
+function testImplicitRejection() {
+  var kp = x.keygen();
+  var enc = x.encapsulate(kp.publicKey);
+  // Wrong key: ML-KEM implicit rejection yields a different 32-byte secret, no throw.
+  var wrong = x.decapsulate(x.keygen().secretKey, enc.ciphertext);
+  check("wrong key yields a 32-byte secret (no throw)", Buffer.isBuffer(wrong) && wrong.length === 32);
+  check("wrong key yields a different secret", !wrong.equals(enc.sharedSecret));
+  // Tampered ciphertext: still no throw, different secret.
+  var bad = Buffer.from(enc.ciphertext); bad[0] ^= 0xff; bad[bad.length - 1] ^= 0xff;
+  var ssBad = x.decapsulate(kp.secretKey, bad);
+  check("tampered ciphertext yields a different secret without throwing", !ssBad.equals(enc.sharedSecret));
+}
+
+function testErrors() {
+  var kp = x.keygen();
+  check("keygen rejects a short seed",       code(function () { x.keygen(Buffer.alloc(16)); }) === "xwing/bad-seed");
+  check("encapsulate rejects a short pubkey", code(function () { x.encapsulate(Buffer.alloc(100)); }) === "xwing/bad-public-key");
+  check("encapsulate rejects a short eseed",  code(function () { x.encapsulate(kp.publicKey, Buffer.alloc(32)); }) === "xwing/bad-eseed");
+  check("decapsulate rejects a short seed",   code(function () { x.decapsulate(Buffer.alloc(16), Buffer.alloc(1120)); }) === "xwing/bad-seed");
+  check("decapsulate rejects a short ct",     code(function () { x.decapsulate(kp.secretKey, Buffer.alloc(100)); }) === "xwing/bad-ciphertext");
+}
+
+async function run() {
+  testSurface();
+  testCombinerKAT();
+  testSizes();
+  testRoundTrip();
+  testDeterminism();
+  testImplicitRejection();
+  testErrors();
+}
+module.exports = { run: run };
+if (require.main === module) { run().then(function () { console.log("[crypto-xwing] OK — " + helpers.getChecks() + " checks passed"); }, function (e) { console.error("FAIL:", e && e.stack || e); process.exit(1); }); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/blamejs-shop",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Open-source framework built on blamejs. Vendored stack, zero npm runtime deps, PQC-first crypto, security-on by default.",
   "main": "lib/index.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "test": "node test/smoke.js",
     "vendor": "bash scripts/vendor-update.sh",
     "sync-assets": "node scripts/sync-r2-assets.js",
-    "deploy": "wrangler deploy && node scripts/sync-r2-assets.js"
+    "release": "node scripts/release.js"
   },
   "engines": {
     "node": ">=24.14.1"