@blamejs/blamejs-shop 0.4.91 → 0.4.92

package/lib/vendor/blamejs/api-snapshot.json

@@ -1,7 +1,7 @@
 {
   "version": 1,
-  "frameworkVersion": "0.15.20",
-  "createdAt": "2026-06-25T03:02:07.070Z",
+  "frameworkVersion": "0.15.23",
+  "createdAt": "2026-06-25T09:00:42.816Z",
   "exports": {
     "a2a": {
       "type": "object",
@@ -2562,6 +2562,10 @@
           "type": "function",
           "arity": 2
         },
+        "fingerprintOf": {
+          "type": "function",
+          "arity": 1
+        },
         "getAlgorithm": {
           "type": "function",
           "arity": 0
@@ -4729,6 +4733,10 @@
               "type": "instance",
               "ctorName": "Array"
             },
+            "VERIFY_ONLY_ALGORITHMS": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
             "compute": {
               "type": "function",
               "arity": 3
@@ -5001,6 +5009,10 @@
           "type": "function",
           "arity": 1
         },
+        "signBytes": {
+          "type": "function",
+          "arity": 1
+        },
         "signingPayload": {
           "type": "function",
           "arity": 1
@@ -5009,6 +5021,10 @@
           "type": "function",
           "arity": 1
         },
+        "verifyBytes": {
+          "type": "function",
+          "arity": 3
+        },
         "verifySignature": {
           "type": "function",
           "arity": 2
@@ -6776,6 +6792,180 @@
         }
       }
     },
+    "codepointClass": {
+      "type": "object",
+      "members": {
+        "BIDI_RANGES": {
+          "type": "instance",
+          "ctorName": "Array"
+        },
+        "BIDI_RE": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "BIDI_RE_G": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "BOM_CHAR": {
+          "type": "primitive",
+          "valueType": "string"
+        },
+        "C0_CTRL_RANGES": {
+          "type": "instance",
+          "ctorName": "Array"
+        },
+        "C0_CTRL_RE": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "C0_CTRL_RE_G": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "HEX_PAIR_RE": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "NULL_BYTE": {
+          "type": "primitive",
+          "valueType": "string"
+        },
+        "NULL_RE_G": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "SCRIPT_RANGES": {
+          "type": "object",
+          "members": {
+            "arabic": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "armenian": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "cherokee": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "cyrillic": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "greek": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "han": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "hangul": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "hebrew": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "hiragana": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "katakana": {
+              "type": "instance",
+              "ctorName": "Array"
+            },
+            "latin": {
+              "type": "instance",
+              "ctorName": "Array"
+            }
+          }
+        },
+        "TAG_RANGES": {
+          "type": "instance",
+          "ctorName": "Array"
+        },
+        "TAG_RE": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "TAG_RE_G": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "ZERO_WIDTH_RANGES": {
+          "type": "instance",
+          "ctorName": "Array"
+        },
+        "ZERO_WIDTH_RE": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "ZW_RE_G": {
+          "type": "instance",
+          "ctorName": "RegExp"
+        },
+        "applyCharStripPolicies": {
+          "type": "function",
+          "arity": 2
+        },
+        "assertNoCharThreats": {
+          "type": "function",
+          "arity": 4
+        },
+        "charClass": {
+          "type": "function",
+          "arity": 1
+        },
+        "decodeNumericEntities": {
+          "type": "function",
+          "arity": 1
+        },
+        "detectCharThreats": {
+          "type": "function",
+          "arity": 4
+        },
+        "detectMixedScripts": {
+          "type": "function",
+          "arity": 2
+        },
+        "escapeRegExp": {
+          "type": "function",
+          "arity": 1
+        },
+        "firstControlCharOffset": {
+          "type": "function",
+          "arity": 2
+        },
+        "fromCp": {
+          "type": "function",
+          "arity": 1
+        },
+        "hex4": {
+          "type": "function",
+          "arity": 1
+        },
+        "isAsciiAlnum": {
+          "type": "function",
+          "arity": 1
+        },
+        "isForbiddenControlChar": {
+          "type": "function",
+          "arity": 2
+        },
+        "isUnreserved": {
+          "type": "function",
+          "arity": 1
+        },
+        "scriptFor": {
+          "type": "function",
+          "arity": 1
+        }
+      }
+    },
     "compliance": {
       "type": "object",
       "members": {
@@ -40407,6 +40597,10 @@
           "type": "function",
           "arity": 1
         },
+        "enterRequestId": {
+          "type": "function",
+          "arity": 1
+        },
         "getRequestId": {
           "type": "function",
           "arity": 0
@@ -49219,6 +49413,10 @@
           "type": "function",
           "arity": 1
         },
+        "ipKey": {
+          "type": "function",
+          "arity": 2
+        },
         "ipPrefix": {
           "type": "function",
           "arity": 2
@@ -52354,6 +52552,10 @@
           "type": "function",
           "arity": 3
         },
+        "casWon": {
+          "type": "function",
+          "arity": 1
+        },
         "cast": {
           "type": "function",
           "arity": 2
@@ -52427,6 +52629,10 @@
           "type": "function",
           "arity": 1
         },
+        "guardedUpdate": {
+          "type": "function",
+          "arity": 2
+        },
         "insert": {
           "type": "function",
           "arity": 2

package/lib/vendor/blamejs/examples/wiki/test/e2e.js

@@ -847,7 +847,10 @@ async function run() {
   console.log("[wiki-e2e] OK — " + checks + " checks passed");
 }
 
-run().catch(function (e) {
-  console.error("[wiki-e2e] FATAL:", e && e.stack || e);
-  process.exit(1);
-});
+module.exports = { run: run };
+if (require.main === module) {
+  run().catch(function (e) {
+    console.error("[wiki-e2e] FATAL:", e && e.stack || e);
+    process.exit(1);
+  });
+}

package/lib/vendor/blamejs/examples/wiki/test/integration.js

@@ -376,16 +376,19 @@ async function run() {
   }
 }
 
-run().then(function () {
-  if (failures.length > 0) {
-    console.error("\n[wiki-integration] FAIL — " + failures.length + " failed assertion(s):");
-    failures.forEach(function (f) { console.error("  ✗ " + f); });
+module.exports = { run: run };
+if (require.main === module) {
+  run().then(function () {
+    if (failures.length > 0) {
+      console.error("\n[wiki-integration] FAIL — " + failures.length + " failed assertion(s):");
+      failures.forEach(function (f) { console.error("  ✗ " + f); });
+      process.exit(1);
+    }
+    console.log("\n[wiki-integration] OK — " + checks + " checks passed");
+    process.exit(0);
+  }, function (err) {
+    console.error("\n[wiki-integration] FAIL — error during run:");
+    console.error(err && err.stack || err);
     process.exit(1);
-  }
-  console.log("\n[wiki-integration] OK — " + checks + " checks passed");
-  process.exit(0);
-}, function (err) {
-  console.error("\n[wiki-integration] FAIL — error during run:");
-  console.error(err && err.stack || err);
-  process.exit(1);
-});
+  });
+}

package/lib/vendor/blamejs/index.js

@@ -124,6 +124,7 @@ var handlers = require("./lib/handlers");
 var safeSql = require("./lib/safe-sql");
 var sql = require("./lib/sql");
 var chainWriter = require("./lib/chain-writer");
+var codepointClass = require("./lib/codepoint-class");
 var safeBuffer = require("./lib/safe-buffer");
 var safeDecompress = require("./lib/safe-decompress").safeDecompress;
 var safeMountInfo = require("./lib/safe-mount-info");
@@ -530,6 +531,7 @@ module.exports = {
   safeSql:          safeSql,
   sql:              sql,
   chainWriter:      chainWriter,
+  codepointClass:   codepointClass,
   safeBuffer:       safeBuffer,
   safeDecompress:   safeDecompress,
   safeMountInfo:    safeMountInfo,

package/lib/vendor/blamejs/lib/audit-sign.js

@@ -498,13 +498,45 @@ function sign(payload) {
  *   // → true (when payload + signature were produced under that key)
  */
 function verify(payload, signature, publicKeyPem) {
-  _requireInit();
+  // Only the DEFAULT-key path needs an initialized keypair; when the caller
+  // supplies an explicit publicKeyPem, verification needs no private material
+  // or in-memory key state. Gating init on the absence of publicKeyPem lets a
+  // verifier-only process (one that holds a trusted public key but never ran
+  // init()) verify a detached signature — the path b.backupManifest.verifyBytes
+  // relies on for downstream verifiers.
+  if (!publicKeyPem) _requireInit();
   var buf = Buffer.isBuffer(payload) ? payload : Buffer.from(String(payload), "utf8");
   var sigBuf = Buffer.isBuffer(signature) ? signature : Buffer.from(signature);
   var pub = publicKeyPem || keys.publicKey;
   return nodeCrypto.verify(null, buf, pub, sigBuf);
 }
 
+/**
+ * @primitive b.auditSign.fingerprintOf
+ * @signature b.auditSign.fingerprintOf(publicKeyPem)
+ * @since     0.15.21
+ * @status    stable
+ * @related   b.auditSign.getPublicKeyFingerprint, b.auditSign.verify
+ *
+ * Compute the SHA3-512 fingerprint (lowercase hex) of a SPKI-PEM public key —
+ * the same derivation `getPublicKeyFingerprint()` returns for the active key,
+ * but for any supplied key and WITHOUT requiring `init()`. A verifier pins a
+ * trusted fingerprint and checks it against `fingerprintOf(block.publicKey)`
+ * before trusting a detached signature block, so an attacker can't substitute
+ * their own key while claiming the trusted fingerprint.
+ *
+ * @example
+ *   var fp = b.auditSign.fingerprintOf(block.publicKey);
+ *   if (fp !== trustedFingerprint) throw new Error("untrusted signing key");
+ */
+function fingerprintOf(publicKeyPem) {
+  if (typeof publicKeyPem !== "string" || publicKeyPem.length === 0) {
+    throw new AuditSignError("audit-sign/bad-public-key",
+      "fingerprintOf: publicKeyPem must be a non-empty PEM string");
+  }
+  return _computeFingerprint(publicKeyPem);
+}
+
 /**
  * @primitive b.auditSign.getPublicKey
  * @signature b.auditSign.getPublicKey()
@@ -1073,6 +1105,7 @@ module.exports = {
   getPublicKey:             getPublicKey,
   getPublicKeyFingerprint:  getPublicKeyFingerprint,
   getPublicKeyByFingerprint: getPublicKeyByFingerprint,
+  fingerprintOf:            fingerprintOf,
   getMode:                  getMode,
   getAlgorithm:             getAlgorithm,
   DEFAULT_SIGNING_ALG:      DEFAULT_SIGNING_ALG,