@blamejs/blamejs-shop 0.3.5 → 0.3.7

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.3.x
 
+- v0.3.7 (2026-05-30) — **Shipping zones now apply at checkout.** The shipping zones you define in the admin console — per-region rates by destination, parcel weight, and order value — now drive the shipping options shown at checkout. When a cart's destination matches a zone, the shopper sees that zone's rates; when no zone matches, or none are defined, checkout falls back to the existing flat-rate table exactly as before, so a store that has not configured zones is entirely unaffected. A fully digital order is never quoted physical shipping. The admin screen for managing zones already shipped; this wires it through to the checkout quote. **Added:** *Zone-based shipping rates at checkout* — When a cart's destination matches a configured shipping zone, the checkout shipping quote uses that zone's rates — resolved by destination country and region, parcel weight, and order subtotal — instead of the flat-rate table. With no matching zone, or no zones defined, checkout returns the existing flat rates unchanged, so the change stays invisible until you set zones up; any lookup error degrades to the same flat fallback. A fully digital order (no shipping-requiring item) is never quoted physical shipping.
+
+- v0.3.6 (2026-05-30) — **Update the vendored blamejs runtime to v0.14.5.** Refreshes the vendored blamejs runtime from v0.13.46 to v0.14.5, a maintenance update. The request-lifecycle security stack the storefront and admin depend on — CSRF, fetch-metadata, body-parser, cookies, and rate limiting — is unchanged across this range. The runtime's breaking changes in this window (stricter OAuth JAR request-object typing and a PGP signature return type) are in surfaces this shop does not use, so there is no behavior change and no operator action is required. **Changed:** *Vendored blamejs runtime updated to v0.14.5* — The pinned blamejs runtime moves from v0.13.46 to v0.14.5, picking up the framework's maintenance and hardening work across that range. The createApp request-lifecycle middleware the shop composes (CSRF, fetch-metadata, body-parser, cookie, and rate-limit layers) is unchanged, so this refresh carries no behavior change for the storefront or admin console.
+
 - v0.3.5 (2026-05-30) — **Shipping-label management in the admin console.** The admin console gains shipping-label tools. On an order, void a purchased label — with a reason — when it needs reprinting, alongside the existing mark-as-used action. A new Shipping labels section adds cross-order visibility: a status-filtered list, the mint queue of labels awaiting a broker, and a broker-spend report that totals label costs by carrier and currency over a date range. This is bookkeeping and reporting only — nothing in the storefront, cart, or checkout changes. **Added:** *Void a shipping label from the order* — Each purchased label on an order now offers a Void action with a reason, for when a label is reprinted at a different weight or carrier. Voiding is refused once a label has been used or already voided, or once it is past the carrier's void window. · *Shipping labels admin section* — A new Shipping labels section gives cross-order visibility: a status-filtered label list, the mint queue of labels awaiting a broker, and a broker-spend report totalling label cost grouped by carrier and currency over a date range.
 
 - v0.3.4 (2026-05-30) — **Sales-tax filings and remittance tracking in the admin console.** The admin console gains a Tax filings section for tracking sales-tax remittance across reporting periods. Open a filing period for a jurisdiction, compute the tax collected from completed orders in that window, then record the submission and the payment as you remit. Each filing carries a per-rate breakdown and an audit trail, and the list surfaces what's due soon or already overdue. A per-jurisdiction remittance report totals the tax owed across a date range. Every figure derives from completed orders — nothing in the storefront, cart, or checkout changes. **Added:** *Tax filings admin console* — A new Tax filings section tracks sales-tax remittance: open a filing period for a jurisdiction and reporting kind, compute the tax collected from completed orders in the window with a per-rate breakdown, then record submission and payment through the filing lifecycle. The list surfaces filings due soon or overdue, and a remittance report totals tax owed per jurisdiction across a date range. This is reporting only — it reads completed orders and changes nothing in checkout.

package/lib/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.5",
+  "version": "0.3.7",
   "assets": {
     "css/admin.css": {
       "integrity": "sha384-1SIn6oAf1DjECbRfKENZasdKHJiywGdXR58wn0hsFGcdVHzUmvfgMkEz5ANIAZJ3",

package/lib/vendor/MANIFEST.json

@@ -3,8 +3,8 @@
   "_about": "blamejs.shop vendors a single framework — blamejs — which itself bundles every server-side crypto/identity dependency. The transitive packages blamejs ships are surfaced in its own MANIFEST.json at lib/vendor/blamejs/lib/vendor/MANIFEST.json — Trivy / Grype rely on that nested data for CVE attribution.",
   "packages": {
     "blamejs": {
-      "version": "0.13.46",
-      "tag": "v0.13.46",
+      "version": "0.14.5",
+      "tag": "v0.14.5",
       "license": "Apache-2.0",
       "author": "blamejs contributors",
       "source": "https://github.com/blamejs/blamejs",
@@ -13,7 +13,7 @@
         "server": "lib/vendor/blamejs/"
       },
       "bundler": "shallow git clone of release tag from github.com/blamejs/blamejs",
-      "bundledAt": "2026-05-29"
+      "bundledAt": "2026-05-30"
     }
   }
 }

package/lib/vendor/blamejs/CHANGELOG.md

@@ -6,6 +6,20 @@ Pre-1.0 the surface is intentionally evolving — every release may
 change something operators depend on. Read each entry before
 upgrading across more than a few patches at a time.
 
+## v0.14.x
+
+- v0.14.5 (2026-05-30) — **Finished cleaning up the mislabeled byte-literal lint suppressions, with no API or behavior changes.** A follow-up to the byte-literal lint tightening. The remaining suppression comments that named the byte-literal check on values that are not byte sizes — JSON-RPC error codes, HTTP status codes, octet ranges, day-in-milliseconds constants — are removed, keeping their explanatory text and any correctly-named companion suppression. Every byte-literal suppression that remains is now on genuine 1024-scale byte arithmetic. Source-comment hygiene only. **Changed:** *Remaining mislabeled byte-literal suppressions removed* — The byte-literal lint was previously a check on any multiple-of-8 integer, so suppression comments naming it were scattered across non-byte values. The last of those (in a handful of files, in mixed comment formats) are now removed — their explanatory text is retained as plain comments, and any correctly-named companion suppression is kept. The only byte-literal suppressions that remain are on genuine 1024-scale byte arithmetic. No change to any exported API, error code, wire format, or runtime behavior.
+
+- v0.14.4 (2026-05-30) — **Removed three pieces of dead code from the SAML, TLS, and JMAP surfaces; no API or behavior changes.** Cleanup of unreachable code. A reverse signature-algorithm lookup in the SAML verifier was never called — the actual verification path resolves the algorithm through the supported-signature table — so it is removed and a stale comment that referenced it is corrected. A leftover no-op placeholder in the TLS certificate re-encode path (a zero-length slice that was assigned and discarded) is removed, leaving the verbatim extension re-encode it sat next to. An unused JMAP well-known-path constant that existed only to be discarded is removed. None of this changes any exported API, error code, wire format, or runtime behavior. **Removed:** *Unreachable code in SAML, TLS, and JMAP* — Removed `_sigAlgFromUri` from the SAML module (a reverse alg lookup that was never called — the embedded XML-DSig verifier resolves the algorithm via the supported-signature table, and the redirect-binding path uses the forward `_sigAlgUrn`), a discarded zero-length-slice placeholder in the TLS certificate extension re-encode path, and an unused well-known-path constant in the JMAP server. Internal cleanup only — no change to any exported API, error code, wire format, or runtime behavior.
+
+- v0.14.3 (2026-05-30) — **A codebase check now ensures every lint-suppression marker names a real check, so a typo can't silently disable a guard.** Source files suppress an individual lint with an `// allow:<class>` comment. If the class is mistyped or stale, the comment suppresses nothing — the check it names does not exist — so the issue it was meant to explain ships unflagged. A new codebase check now verifies every `// allow:<class>` marker names a registered check class and fails if it does not, with the full set of valid classes maintained as an explicit registry. Two markers that named a non-kebab class were corrected as part of this. No runtime, API, or wire-format changes. **Detectors:** *Lint-suppression markers must name a registered check* — A new check flags any `// allow:<class>` suppression comment whose class is not one of the registered check classes — catching typos and stale markers (for example a marker that named a check which was later renamed) that would otherwise silently disable the guard they appear to explain. The valid classes are kept as an explicit registry, so adding a check with a new allow-class is a one-line registration. Source-comment hygiene only — no change to any exported API, error code, wire format, or runtime behavior.
+
+- v0.14.2 (2026-05-29) — **Internal lint hygiene: the byte-literal check now flags only genuine byte-scale arithmetic, with no API or behavior changes.** A no-behavior-change cleanup of the source tree's internal lint markers. The byte-literal lint previously flagged every integer that was a multiple of 8 — which is most numbers — so the source carried a large number of suppression comments on values that were not byte sizes at all (status codes, counts, lengths, radixes, opcodes). The lint now flags only 1024-scale byte arithmetic (the case the C.BYTES.kib/mib/gib helpers exist to replace), and the now-unnecessary suppression comments have been removed while keeping their explanatory text. Several lint-suppression markers that named a check that does not exist were also corrected. None of this changes any API, wire format, or runtime behavior. **Changed:** *Source-tree lint markers cleaned up* — The internal byte-literal lint was tightened to flag only genuine byte-scale (`* 1024`) arithmetic, and the suppression comments it previously required on non-byte integers were removed (their explanatory text is retained as plain comments). A handful of suppression markers that referenced a non-existent check were pointed at the correct one or removed. This is source-comment hygiene only — there is no change to any exported API, error code, wire format, or runtime behavior.
+
+- v0.14.1 (2026-05-29) — **Correctness fixes: JAR request-object typ enforcement, byte-faithful PGP multipart/signed, and SAML InResponseTo binding.** A set of correctness fixes across the auth, mail-crypto, TLS, and encoder surfaces. The most important: JWT-secured authorization requests (RFC 9101) now require the request object to carry the registered `oauth-authz-req+jwt` typ, closing a cross-JWT-confusion vector; the PGP multipart/signed wrapper is now assembled byte-faithfully so non-ASCII signed content can't be corrupted; and SAML response verification now returns the InResponseTo of the SubjectConfirmation that actually validated. Two of these change behavior — see Changed — and are bug fixes rather than new features. **Changed:** *JAR parsing rejects untyped request objects (breaking)* — Following the typ enforcement above, a request object whose header omits `typ` is now refused. An authorization server whose clients sign request objects without the `oauth-authz-req+jwt` typ must update those clients to set it. · *PGP sign() returns multipartSigned as a Buffer (breaking)* — `b.mail.crypto.pgp.sign(...).multipartSigned` is now a Buffer instead of a string. The OpenPGP signature covers the signed-part bytes exactly, and a JS-string round trip through latin1/utf8 could corrupt non-ASCII signed content and break verification, so the RFC 3156 multipart/signed wrapper is now assembled as bytes. Code that wrote the previous string to the wire works unchanged when it writes the Buffer; code that did string operations on the value should treat it as a Buffer (its `indexOf` / `toString` still work). **Fixed:** *SAML response verification binds InResponseTo to the validated confirmation* — `verifyResponse` returned the InResponseTo of the first SubjectConfirmationData in the assertion rather than of the SubjectConfirmation that actually passed bearer validation. When a response carried more than one SubjectConfirmation, the returned value could come from a non-validated confirmation. It is now the InResponseTo of the confirmation that validated. · *checkServerIdentity9525 emits the documented CN-fallback audit code* — A CN-only legacy certificate (a Common Name present, no subjectAltName) is now refused by the exported `b.network.tls.checkServerIdentity9525` with the distinct `tls/pkix-cn-fallback-refused` code its documentation promised, so audit logs can tell a CN-only certificate apart from one carrying neither a SAN nor a CN (which still yields `tls/pkix-san-required`). The accept/refuse outcome is unchanged — both are refused; only the audit granularity improved. · *OIDC back-channel logout / JARM no longer accept dead override parameters* — `verifyBackchannelLogoutToken` and `parseJarmResponse` passed `acceptedAlgs` / `jwksUri` / `maxClockSkewMs` through to the ID-token verifier, which ignored them and applied the configured (create()-time) values. The pass-throughs are removed so the code no longer reads as if those can be overridden per call; the configured trust anchor was — and remains — what applies. · *Queue lease failures are logged* — The consumer loop's lease-acquisition error path swallowed the backend error silently; it now logs at debug so a flapping backend that has not yet tripped the circuit breaker is visible. · *Protobuf and ASN.1 encoders reject out-of-range tags* — The protobuf tag encoder rejected nothing and would have emitted a wrong tag for field numbers at or above 2^28 (where the 32-bit shift overflows); the ASN.1 context-tag writers silently truncated tag numbers above 30 (which require the multi-byte high-tag-number form). Both now throw a RangeError rather than encode silently-wrong output. The values these encoders serve are well within range, so no current caller is affected. · *oid4vci proofAlgorithms default documented accurately* — The documented default proof-algorithm list now matches the code (`["ES256", "ES384", "EdDSA"]`); the doc previously omitted EdDSA, which the runtime has always accepted by default. **Security:** *JAR request objects must carry the registered typ (RFC 9101)* — `b.auth.jar.parse` now requires the request-object JWS header to carry `typ: "oauth-authz-req+jwt"` (with or without the `application/` prefix); a request object with an absent or different typ is refused with `auth-jar/bad-typ`. RFC 9101 §10.8 specifies this media type precisely to stop a JWT minted for another purpose (an ID token, an access token, a logout token) and signed by the same client key from being replayed as a request object. The existing `iss` / `aud` / `client_id` bindings already constrained that; this restores the explicit type check as well. This is stricter than before — see Changed.
+
+- v0.14.0 (2026-05-29) — **Operator-configurable header and field names across SSE, request-id, rate-limit, age-gate, AI-Act disclosure, GraphQL federation, and the HTTP cache.** This release makes operator-facing identifiers that were hardcoded configurable. The framework already let operators rename most names (CSRF cookie/field, cookie parser, i18n header/query/cookie, mTLS CA name, and so on); this closes the remaining gaps so a custom or framework-specific name is never frozen. Every new option defaults to the value emitted today, so upgrading changes no behavior — these are additive knobs. It also fixes a request-id asymmetry (the response header is now written on the same name the inbound id is read from) and wires an SSE proxy-buffering option whose escape hatch was documented but never implemented. **Added:** *Configurable cache-status header on the HTTP client* — The outbound HTTP client annotated every cached response with a hardcoded `x-blamejs-cache: HIT|MISS|STALE|REVALIDATED` header. `b.httpClient.cache.create` now takes `statusHeader` (default "x-blamejs-cache") — pass a custom name (e.g. "x-cache") to rename it, or null/false to suppress it entirely. The decision remains available programmatically on `res.cacheStatus`. · *Configurable rate-limit header names* — `b.middleware.rateLimit` emitted the de-facto `X-RateLimit-Limit` / `X-RateLimit-Remaining` headers (which are not RFC-pinned). It now accepts `headerPrefix` (default "X-RateLimit-") so operators can match the unprefixed IETF-draft `RateLimit-*` names or an upstream gateway's convention; the limit/remaining pair is always built from the same prefix. · *Configurable age-gate and AI-Act disclosure header names* — `b.middleware.ageGate` now takes `privacyPostureHeader` (default "X-Privacy-Posture"; null/false to suppress), and `b.middleware.aiActDisclosure` takes `headerPrefix` (default "AI-Act-") that prefixes the emitted Notice / Article / Policy headers. The EU AI Act mandates the disclosure, not the HTTP spelling, so operators matching a downstream convention can rename these. · *Configurable GraphQL-federation replay-nonce header* — `b.graphqlFederation.guardSdl` read the replay nonce from the Apollo-vendor `x-apollographql-router-nonce` header with no override. It now accepts `nonceHeader` (default unchanged) so an operator fronting the gateway with a non-Apollo router can point the replay check at their own header. · *SSE proxy-buffering opt-out* — `b.sse.create` and `b.middleware.sse` set `X-Accel-Buffering: no` (the nginx hint that disables proxy buffering). They now accept `proxyBuffer` (default true) — pass false when not behind nginx, or when buffering is controlled at the load balancer, to suppress the nginx-specific header. The opt-out was previously referenced in the documentation but not implemented. **Fixed:** *Request-id middleware reflects the configured header name* — `b.log.middleware` read the inbound request id from a configurable `headerName` but always wrote the response on the literal `X-Request-Id`. An operator who set a custom `headerName` (e.g. `X-Correlation-Id`) therefore read from one header and emitted another. The response is now written on the same configured name; the default remains `X-Request-Id`, so deployments that did not set `headerName` are unaffected.
+
 ## v0.13.x
 
 - v0.13.46 (2026-05-29) — **`createApp` now wires the documented security middleware ON by default — CSRF, CSP nonce, cookie parser, fetch-metadata, and body parser.** The README has long described a security middleware stack as "wired by createApp", but createApp only mounted request-ID, security-headers, and bot-guard by default — CSRF protection, the CSP nonce, the threat-aware cookie parser, the fetch-metadata guard, and the body parser were documented but not actually wired. This release closes that gap: createApp now mounts all of them by default, in dependency order (cookies, CSP nonce, fetch-metadata, then body parser, then CSRF last so it can read a body-field token). This is a behavior change — apps built with createApp now enforce CSRF on state-changing requests by default. Each layer is configurable via opts.middleware.<name> (operator cookie and field names flow straight through — nothing is hardcoded) or can be turned off with false, and disabling a security default now emits an app.middleware.disabled audit event. Every layer is idempotent: an operator who also mounts one of these inside opts.routes gets a no-op second mount rather than a double-apply. The default CSRF is a double-submit cookie that auto-skips requests carrying an Authorization header or no cookies at all, which are not CSRF-able, so token-authenticated API clients are not rejected. The README middleware list is now an accurate description of what createApp wires. **Added:** *Idempotent security middleware* — The cookie parser, CSP nonce, fetch-metadata, and CSRF middleware are now idempotent within a request: if one has already run (because createApp wired it and an operator also mounted it), the second instance is a no-op rather than re-parsing, re-generating a nonce, or issuing a second CSRF cookie. This lets an application compose its own middleware order on top of createApp's defaults without double-applying. The body parser already had this behavior. **Changed:** *createApp wires CSRF, CSP nonce, cookie parser, fetch-metadata, and body parser by default (breaking)* — Applications constructed with b.createApp now mount, in order: the threat-aware cookie parser, the CSP nonce generator, the fetch-metadata resource-isolation guard, the body parser (JSON / urlencoded / text / multipart), and CSRF protection — in addition to the request-ID, security-headers, and bot-guard layers already wired. The ordering guarantees CSRF runs after the body parser so a body-field token is available. This is a behavior change: state-changing requests (POST / PUT / DELETE / PATCH) that carry a session cookie are now CSRF-validated by default. Each layer is configured through opts.middleware.<name> (an object passes operator options straight through; cookie and field names are not hardcoded) or disabled with false. Operators who were mounting these middleware themselves inside opts.routes do not need to change anything — the second mount is now a no-op (see idempotency below). · *Default CSRF auto-skips token-authenticated and cookieless requests* — The CSRF middleware gains a skipStateless option (default false; createApp's default wiring sets it true). When on, token validation is skipped for requests that carry an Authorization header or no Cookie header at all — such requests are not CSRF-able, because CSRF abuses a victim's ambient cookie credential and these have none. The token is still issued on safe methods so a later cookie-authenticated browser flow works. Cross-site form CSRF is unaffected: the browser auto-sends the victim's cookies, so an attack request always carries a Cookie header and is validated. · *Disabling a default security middleware is audited* — Passing false for one of the security-on-by-default middleware (for example middleware: { csrf: false }) now emits an app.middleware.disabled audit event naming the middleware, so a weakened posture leaves a trace in the audit chain rather than being silent.

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

@@ -1,7 +1,7 @@
 {
   "version": 1,
-  "frameworkVersion": "0.13.46",
-  "createdAt": "2026-05-30T02:15:44.237Z",
+  "frameworkVersion": "0.14.5",
+  "createdAt": "2026-05-30T14:33:33.657Z",
   "exports": {
     "a2a": {
       "type": "object",

package/lib/vendor/blamejs/lib/_test/crypto-fixtures.js

@@ -47,15 +47,15 @@ function mintLegacyEnvelope0xE1(plaintext, recipient) {
   var nonce = bCrypto.generateBytes(C.BYTES.bytes(24));
   // Legacy 0xE1 envelope header — 4 bytes: magic, kemId, cipherId, kdfId.
   var headerAad = Buffer.from([
-    0xE1,                                                                                            // allow:raw-byte-literal — legacy 0xE1 envelope magic byte
+    0xE1,                                                                                            // legacy 0xE1 envelope magic byte
     C.KEM_IDS.ML_KEM_1024_P384,
     C.CIPHER_IDS.XCHACHA20_POLY1305,
     C.KDF_IDS.SHAKE256,
   ]);
   var ct = xchacha20poly1305(key, nonce, headerAad).encrypt(Buffer.from(plaintext, "utf8"));
-  var kemCtLen = Buffer.alloc(2); kemCtLen.writeUInt16BE(kem.ciphertext.length);                     // allow:raw-byte-literal — 16-bit length-prefix field
+  var kemCtLen = Buffer.alloc(2); kemCtLen.writeUInt16BE(kem.ciphertext.length);                     // 16-bit length-prefix field
   var ecEphDer = ephEc.publicKey;
-  var ecEphLen = Buffer.alloc(2); ecEphLen.writeUInt16BE(ecEphDer.length);                           // allow:raw-byte-literal — 16-bit length-prefix field
+  var ecEphLen = Buffer.alloc(2); ecEphLen.writeUInt16BE(ecEphDer.length);                           // 16-bit length-prefix field
   return Buffer.concat([
     headerAad,
     kemCtLen, kem.ciphertext, ecEphLen, ecEphDer, nonce, Buffer.from(ct),

package/lib/vendor/blamejs/lib/a2a-tasks.js

@@ -62,17 +62,17 @@ var A2aTasksError = defineClass("A2aTasksError", { alwaysPermanent: true });
 var JSONRPC_VERSION = "2.0";
 
 // JSON-RPC 2.0 fixed error codes — A2A inherits these.
-var JSONRPC_PARSE_ERROR      = -32700;                                                             // allow:raw-byte-literal — JSON-RPC fixed code / allow:raw-time-literal — not seconds
-var JSONRPC_INVALID_REQUEST  = -32600;                                                             // allow:raw-byte-literal — JSON-RPC fixed code / allow:raw-time-literal — not seconds
-var JSONRPC_METHOD_NOT_FOUND = -32601;                                                             // allow:raw-byte-literal — JSON-RPC fixed code / allow:raw-time-literal — not seconds
-var JSONRPC_INVALID_PARAMS   = -32602;                                                             // allow:raw-byte-literal — JSON-RPC fixed code / allow:raw-time-literal — not seconds
-var JSONRPC_INTERNAL_ERROR   = -32603;                                                             // allow:raw-byte-literal — JSON-RPC fixed code / allow:raw-time-literal — not seconds
+var JSONRPC_PARSE_ERROR      = -32700;                                                             // allow:raw-time-literal — not seconds
+var JSONRPC_INVALID_REQUEST  = -32600;                                                             // allow:raw-time-literal — not seconds
+var JSONRPC_METHOD_NOT_FOUND = -32601;                                                             // allow:raw-time-literal — not seconds
+var JSONRPC_INVALID_PARAMS   = -32602;                                                             // allow:raw-time-literal — not seconds
+var JSONRPC_INTERNAL_ERROR   = -32603;                                                             // allow:raw-time-literal — not seconds
 
 // A2A-specific error codes per the spec's task-error vocabulary.
 // A2A_TASK_NOT_FOUND (-32002) + A2A_TASK_NOT_CANCELABLE (-32003) are
 // raised by operator handlers — they're reserved here for documentation
 // purposes only.
-var A2A_SCOPE_DENIED         = -32001;                                                             // allow:raw-byte-literal — JSON-RPC server-error range / allow:raw-time-literal — not seconds
+var A2A_SCOPE_DENIED         = -32001;                                                             // allow:raw-time-literal — not seconds
 
 var ALLOWED_METHODS = Object.freeze(["tasks/send", "tasks/get", "tasks/cancel"]);
 
@@ -80,7 +80,7 @@ var TASK_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
 // Same identifier shape as MCP tool-name; consolidating would couple
 // MCP + A2A protocol identifiers into a single primitive.
 var SKILL_NAME_RE = /^[a-zA-Z][a-zA-Z0-9._-]{0,63}$/;   // allow:duplicate-regex — RFC-3986-unreserved identifier shape, shared across mcp.js + mcp-tool-registry.js
-// allow:raw-byte-literal — RFC-3986-unreserved identifier shape (length cap inside regex), not a byte count
+// RFC-3986-unreserved identifier shape (length cap inside regex), not a byte count
 
 function _emitAudit(action, metadata, outcome) {
   try {
@@ -99,7 +99,7 @@ var bCrypto = lazyRequire(function () { return require("./crypto"); });
 // satisfies the framework's unused-var policy so the helper stays
 // available without an explicit disable directive.
 function _newTaskId() {
-  return bCrypto().generateToken(12);                                                               // allow:raw-byte-literal — 96-bit task id, not byte arithmetic on payload
+  return bCrypto().generateToken(12);                                                               // 96-bit task id, not byte arithmetic on payload
 }
 
 function _validateTaskShape(task, where) {
@@ -108,7 +108,7 @@ function _validateTaskShape(task, where) {
       where + ": task must be a non-null object", true);
   }
   validateOpts.requireNonEmptyString(task.skill, where + ".skill", A2aTasksError, "a2a-tasks/bad-skill");
-  if (task.skill.length > 64 || !SKILL_NAME_RE.test(task.skill)) {                                // allow:raw-byte-literal — A2A skill-name length cap, not byte count
+  if (task.skill.length > 64 || !SKILL_NAME_RE.test(task.skill)) {                                // A2A skill-name length cap, not byte count
 
     throw new A2aTasksError("a2a-tasks/bad-skill",
       where + ".skill '" + task.skill + "' must match " + SKILL_NAME_RE);
@@ -196,7 +196,7 @@ async function get(opts) {
   }
   validateOpts.requireNonEmptyString(opts.peerUrl, "tasks.get.peerUrl", A2aTasksError, "a2a-tasks/bad-peer-url");
   validateOpts.requireNonEmptyString(opts.taskId, "tasks.get.taskId", A2aTasksError, "a2a-tasks/bad-task-id");
-  if (opts.taskId.length > 64 || !TASK_ID_RE.test(opts.taskId)) {                                  // allow:raw-byte-literal — A2A task-id length cap, not byte count
+  if (opts.taskId.length > 64 || !TASK_ID_RE.test(opts.taskId)) {                                  // A2A task-id length cap, not byte count
     throw new A2aTasksError("a2a-tasks/bad-task-id",
       "tasks.get: taskId must match " + TASK_ID_RE);
   }
@@ -239,7 +239,7 @@ async function cancel(opts) {
   }
   validateOpts.requireNonEmptyString(opts.peerUrl, "tasks.cancel.peerUrl", A2aTasksError, "a2a-tasks/bad-peer-url");
   validateOpts.requireNonEmptyString(opts.taskId, "tasks.cancel.taskId", A2aTasksError, "a2a-tasks/bad-task-id");
-  if (opts.taskId.length > 64 || !TASK_ID_RE.test(opts.taskId)) {                                  // allow:raw-byte-literal — A2A task-id length cap, not byte count
+  if (opts.taskId.length > 64 || !TASK_ID_RE.test(opts.taskId)) {                                  // A2A task-id length cap, not byte count
     throw new A2aTasksError("a2a-tasks/bad-task-id",
       "tasks.cancel: taskId must match " + TASK_ID_RE);
   }
@@ -280,7 +280,7 @@ async function _jsonRpc(url, method, params, opts) {
     throw new A2aTasksError("a2a-tasks/transport",
       "tasks." + method.split("/")[1] + ": transport error: " + (transportErr.message || transportErr));
   }
-  if (rsp.statusCode < 200 || rsp.statusCode >= 300) {                                             // allow:raw-byte-literal — HTTP status class boundaries
+  if (rsp.statusCode < 200 || rsp.statusCode >= 300) {                                             // HTTP status class boundaries
     if (opts.audit) {
       _emitAudit("a2a.tasks.http_error",
         { method: method, url: url, statusCode: rsp.statusCode, elapsedMs: Date.now() - startMs },
@@ -395,7 +395,7 @@ function middlewareTasks(opts) {
 
   return function a2aTasksMiddleware(req, res) {
     if ((req.method || "").toUpperCase() !== "POST") {
-      res.statusCode = 405;                                                                        // allow:raw-byte-literal — HTTP 405 Method Not Allowed
+      res.statusCode = 405;                                                                        // HTTP 405 Method Not Allowed
       res.setHeader("Content-Type", "application/json");
       res.setHeader("Allow", "POST");
       res.end(JSON.stringify(_jsonRpcError(null, JSONRPC_INVALID_REQUEST, "method must be POST")));
@@ -403,7 +403,7 @@ function middlewareTasks(opts) {
     }
     var ctype = (req.headers && (req.headers["content-type"] || req.headers["Content-Type"])) || "";
     if (typeof ctype === "string" && ctype.indexOf("application/json") !== 0 && ctype.indexOf("application/json") === -1) {
-      res.statusCode = 415;                                                                        // allow:raw-byte-literal — HTTP 415 Unsupported Media Type
+      res.statusCode = 415;                                                                        // HTTP 415 Unsupported Media Type
       res.setHeader("Content-Type", "application/json");
       res.end(JSON.stringify(_jsonRpcError(null, JSONRPC_INVALID_REQUEST, "Content-Type must be application/json")));
       return;
@@ -414,14 +414,14 @@ function middlewareTasks(opts) {
       try {
         body = safeJson.parse(rawBytes.toString("utf8"), { maxBytes: maxBytes });
       } catch (_parseErr) {
-        res.statusCode = 400;                                                                      // allow:raw-byte-literal — HTTP 400 Bad Request
+        res.statusCode = 400;                                                                      // HTTP 400 Bad Request
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify(_jsonRpcError(null, JSONRPC_PARSE_ERROR, "invalid JSON body")));
         return;
       }
       if (!body || typeof body !== "object" || body.jsonrpc !== JSONRPC_VERSION ||
           typeof body.method !== "string") {
-        res.statusCode = 400;                                                                      // allow:raw-byte-literal — HTTP 400 Bad Request
+        res.statusCode = 400;                                                                      // HTTP 400 Bad Request
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify(_jsonRpcError(body && body.id, JSONRPC_INVALID_REQUEST,
           "expected JSON-RPC 2.0 envelope { jsonrpc, id?, method, params? }")));
@@ -429,7 +429,7 @@ function middlewareTasks(opts) {
       }
       var reqId = body.id !== undefined ? body.id : null;
       if (ALLOWED_METHODS.indexOf(body.method) === -1) {
-        res.statusCode = 200;                                                                      // allow:raw-byte-literal — JSON-RPC errors return 200 with error envelope
+        res.statusCode = 200;                                                                      // JSON-RPC errors return 200 with error envelope
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify(_jsonRpcError(reqId, JSONRPC_METHOD_NOT_FOUND,
           "method '" + body.method + "' not in [" + ALLOWED_METHODS.join(", ") + "]")));
@@ -440,7 +440,7 @@ function middlewareTasks(opts) {
       // Scope enforcement for tasks/send (task references a skill).
       if (body.method === "tasks/send" && scopes) {
         if (!params.task || typeof params.task !== "object" || typeof params.task.skill !== "string") {
-          res.statusCode = 200;                                                                    // allow:raw-byte-literal — JSON-RPC error envelope returns 200
+          res.statusCode = 200;                                                                    // JSON-RPC error envelope returns 200
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify(_jsonRpcError(reqId, JSONRPC_INVALID_PARAMS,
             "tasks/send: params.task.skill required")));
@@ -454,7 +454,7 @@ function middlewareTasks(opts) {
               _emitAudit("a2a.tasks.scope_denied",
                 { skill: params.task.skill, requiredScope: requiredScope }, "denied");
             }
-            res.statusCode = 200;                                                                  // allow:raw-byte-literal — JSON-RPC error envelope returns 200
+            res.statusCode = 200;                                                                  // JSON-RPC error envelope returns 200
             res.setHeader("Content-Type", "application/json");
             res.end(JSON.stringify(_jsonRpcError(reqId, A2A_SCOPE_DENIED,
               "scope '" + requiredScope + "' required for skill '" + params.task.skill + "'")));
@@ -476,7 +476,7 @@ function middlewareTasks(opts) {
             _emitAudit("a2a.tasks.handled",
               { method: body.method, skill: params.task && params.task.skill, taskId: params.taskId });
           }
-          res.statusCode = 200;                                                                    // allow:raw-byte-literal — JSON-RPC 200 with result envelope
+          res.statusCode = 200;                                                                    // JSON-RPC 200 with result envelope
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify({
             jsonrpc: JSONRPC_VERSION,
@@ -491,12 +491,12 @@ function middlewareTasks(opts) {
             _emitAudit("a2a.tasks.handler_error",
               { method: body.method, errorMessage: msg, errorCode: code }, "warning");
           }
-          res.statusCode = 200;                                                                    // allow:raw-byte-literal — JSON-RPC error envelope returns 200
+          res.statusCode = 200;                                                                    // JSON-RPC error envelope returns 200
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify(_jsonRpcError(reqId, code, msg)));
         });
     }).catch(function (readErr) {
-      res.statusCode = 400;                                                                        // allow:raw-byte-literal — HTTP 400 Bad Request
+      res.statusCode = 400;                                                                        // HTTP 400 Bad Request
       res.setHeader("Content-Type", "application/json");
       res.end(JSON.stringify(_jsonRpcError(null, JSONRPC_PARSE_ERROR,
         "could not read request body: " + (readErr.message || readErr))));
@@ -573,12 +573,12 @@ function middlewareAgentCard(opts) {
   var cardJson = JSON.stringify(opts.card);
   return function a2aAgentCardMiddleware(req, res) {
     if ((req.method || "").toUpperCase() !== "GET") {
-      res.statusCode = 405;                                                                        // allow:raw-byte-literal — HTTP 405 Method Not Allowed
+      res.statusCode = 405;                                                                        // HTTP 405 Method Not Allowed
       res.setHeader("Allow", "GET");
       res.end();
       return;
     }
-    res.statusCode = 200;                                                                          // allow:raw-byte-literal — HTTP 200 OK
+    res.statusCode = 200;                                                                          // HTTP 200 OK
     res.setHeader("Content-Type", "application/json");
     res.setHeader("Cache-Control", "public, max-age=" + maxAgeSec);
     res.end(cardJson);

package/lib/vendor/blamejs/lib/a2a.js

@@ -39,10 +39,10 @@ var audit = require("./audit");
 var { A2aError } = require("./framework-error");
 
 var REQUIRED_CARD_FIELDS = ["issuer", "agentId", "capabilities", "version"];
-var ID_MAX     = 256;                                                                       // allow:raw-byte-literal — string-length cap, not bytes
-var SEMVER_MAX = 64;                                                                        // allow:raw-byte-literal — string-length cap, not bytes
-var CAP_NAME_MAX = 128;                                                                     // allow:raw-byte-literal — string-length cap, not bytes
-var SHAKE256_BYTES = 64;                                                                    // allow:raw-byte-literal — SHA3-512 output is 64 bytes (FIPS 202)
+var ID_MAX     = 256;                                                                       // string-length cap, not bytes
+var SEMVER_MAX = 64;                                                                        // string-length cap, not bytes
+var CAP_NAME_MAX = 128;                                                                     // string-length cap, not bytes
+var SHAKE256_BYTES = 64;                                                                    // SHA3-512 output is 64 bytes (FIPS 202)
 var ID_RE     = /^[a-zA-Z0-9._:/-]{1,256}$/;
 var SEMVER_RE = /^[0-9]+\.[0-9]+(?:\.[0-9]+)?(?:-[A-Za-z0-9.-]+)?$/;
 

package/lib/vendor/blamejs/lib/acme.js

@@ -138,7 +138,7 @@ function _signJws(privateKey, protectedHeader, payload) {
   // ECDSA from node:crypto returns DER-encoded (r,s); RFC 7515 requires
   // raw concatenation of r||s, each padded to the curve byte size (32
   // for P-256).
-  var rawSig = _ecdsaDerToRaw(derSig, 32);                                       // allow:raw-byte-literal — RFC 7518 §3.4 ES256 signature half-length (P-256 byte size)
+  var rawSig = _ecdsaDerToRaw(derSig, 32);                                       // RFC 7518 §3.4 ES256 signature half-length (P-256 byte size)
   return {
     protected: protB64,
     payload:   payloadB64,
@@ -1432,8 +1432,8 @@ function _base32lc(buf) {
   var bits = 0;
   var value = 0;
   for (var i = 0; i < buf.length; i += 1) {
-    value = (value << 8) | buf[i];   // allow:raw-byte-literal — bit-shift count, byte boundary
-    bits += 8;                       // allow:raw-byte-literal — bits-per-byte constant
+    value = (value << 8) | buf[i];   // bit-shift count, byte boundary
+    bits += 8;                       // bits-per-byte constant
     while (bits >= 5) {
       out += alphabet[(value >>> (bits - 5)) & 31];
       bits -= 5;

package/lib/vendor/blamejs/lib/agent-idempotency.js

@@ -430,7 +430,7 @@ function _actorIdHash(actorId) {
 
 function _truncHash(hash) {
   if (typeof hash !== "string") return "";
-  return hash.slice(0, 16);                                                                            // allow:raw-byte-literal — audit-log truncation length, not a size cap
+  return hash.slice(0, 16);                                                                            // audit-log truncation length, not a size cap
 }
 
 function _fingerprintArgs(args) {

package/lib/vendor/blamejs/lib/agent-orchestrator.js

@@ -117,7 +117,7 @@ function _unsealRegistryRow(row) {
 }
 
 var DEFAULT_DRAIN_TIMEOUT_MS = C.TIME.minutes(2);
-var STREAM_ID_RAND_BYTES     = 8;                                                                     // allow:raw-byte-literal — stream-id random-suffix byte length, not a size cap
+var STREAM_ID_RAND_BYTES     = 8;                                                                     // stream-id random-suffix byte length, not a size cap
 var DEFAULT_PER_CONSUMER_STOP_MS = C.TIME.seconds(5);
 // SUBSTRATE-20 — FNV-1a offset basis salted with the first 32 bits of
 // SHA3-512(vault master). Attackers who don't have read access to the
@@ -428,7 +428,7 @@ function _spawnConsumers(ctx, args) {
       "spawnConsumers: queue with .consume() required");
   }
   var shards = typeof args.shards === "number" ? args.shards : 1;
-  if (!Number.isInteger(shards) || shards < 1 || shards > 256) {                                      // allow:raw-byte-literal — shard cap
+  if (!Number.isInteger(shards) || shards < 1 || shards > 256) {                                      // shard cap
     throw new AgentOrchestratorError("agent-orchestrator/bad-shard-count",
       "spawnConsumers: shards must be an integer in 1..256");
   }
@@ -508,21 +508,21 @@ function _saltedFnvBasis() {
   var v;
   try { v = vault(); } catch (_e) { v = null; }
   if (!v || typeof v.getKeysJson !== "function") {
-    _saltedFnvBasisCache = 2166136261;                                                                  // allow:raw-byte-literal — FNV-1a offset basis (vault-less fallback)
+    _saltedFnvBasisCache = 2166136261;                                                                  // FNV-1a offset basis (vault-less fallback)
     return _saltedFnvBasisCache;
   }
   var keysJson;
   try { keysJson = v.getKeysJson(); }
   catch (_e) {
-    _saltedFnvBasisCache = 2166136261;                                                                  // allow:raw-byte-literal — FNV-1a offset basis (vault-init-pending fallback)
+    _saltedFnvBasisCache = 2166136261;                                                                  // FNV-1a offset basis (vault-init-pending fallback)
     return _saltedFnvBasisCache;
   }
   var hashHex = bCrypto.sha3Hash(keysJson);
   // Read the first 32 bits as the salt; mix into the offset basis via
   // XOR so the distribution properties of FNV are preserved.
-  var saltBuf = Buffer.from(hashHex.slice(0, 8), "hex");                                                // allow:raw-byte-literal — 32-bit prefix of SHA3-512 hex (4 bytes = 8 hex chars)
+  var saltBuf = Buffer.from(hashHex.slice(0, 8), "hex");                                                // 32-bit prefix of SHA3-512 hex (4 bytes = 8 hex chars)
   var salt = saltBuf.readUInt32BE(0);
-  _saltedFnvBasisCache = ((2166136261 ^ salt) >>> 0);                                                   // allow:raw-byte-literal — FNV-1a offset basis (vault-salted)
+  _saltedFnvBasisCache = ((2166136261 ^ salt) >>> 0);                                                   // FNV-1a offset basis (vault-salted)
   return _saltedFnvBasisCache;
 }
 
@@ -535,7 +535,7 @@ function shardFor(shardKey, shards) {
   var h = _saltedFnvBasis();
   for (var i = 0; i < shardKey.length; i += 1) {
     h ^= shardKey.charCodeAt(i);
-    h = (h * 16777619) >>> 0;                                                                         // allow:raw-byte-literal — FNV-1a prime
+    h = (h * 16777619) >>> 0;                                                                         // FNV-1a prime
   }
   return h % shards;
 }
@@ -710,7 +710,7 @@ async function _quiesceInFlight(ctx, startedAt, timeoutMs) {
     }
     if (!anyInFlight) return true;
     await new Promise(function (r) {
-      var t = setTimeout(r, 50);                                                                       // allow:raw-byte-literal — 50ms in-flight poll interval
+      var t = setTimeout(r, 50);                                                                       // 50ms in-flight poll interval
       if (t && typeof t.unref === "function") t.unref();
     });
   }

package/lib/vendor/blamejs/lib/agent-posture-chain.js

@@ -72,12 +72,12 @@ var BUILTIN_REGIMES = Object.freeze(["hipaa", "pci-dss", "gdpr", "soc2"]);
 // SHAPE, not authenticity). Defense is a keyed MAC over the canonical
 // envelope bytes, computed at appendHop and verified at validate.
 var ENVELOPE_MAC_LABEL = "blamejs.agent.postureChain/v1";
-var ENVELOPE_MAC_KEY_BYTES = 32;                                                                        // allow:raw-byte-literal — HMAC-SHA3-512 keyed bytes
+var ENVELOPE_MAC_KEY_BYTES = 32;                                                                        // HMAC-SHA3-512 keyed bytes
 // SUBSTRATE-21 — hop count cap defends infinite recursion across
 // agent delegation. 16 is the spec default; operators can lower via
 // opts.maxHopCount but never raise (audit fan-out without a cap is a
 // DoS class).
-var DEFAULT_MAX_HOP_COUNT = 16;                                                                         // allow:raw-byte-literal — hop count cap
+var DEFAULT_MAX_HOP_COUNT = 16;                                                                         // hop count cap
 var _macKeyCache = null;                                                                                // memoized per-vault-master key
 
 function _resolveMacKey() {

package/lib/vendor/blamejs/lib/agent-saga.js

@@ -80,7 +80,7 @@ var audit              = lazyRequire(function () { return require("./audit"); })
 
 var AgentSagaError = defineClass("AgentSagaError", { alwaysPermanent: true });
 
-var SAGA_ID_RAND_BYTES = 8;                                                                           // allow:raw-byte-literal — saga-id random-suffix byte length
+var SAGA_ID_RAND_BYTES = 8;                                                                           // saga-id random-suffix byte length
 
 /**
  * @primitive b.agent.saga.create

package/lib/vendor/blamejs/lib/agent-snapshot.js

@@ -71,7 +71,7 @@ var DEFAULT_DRAIN_TIMEOUT_MS     = C.TIME.minutes(2);
 var DEFAULT_SNAPSHOT_INTERVAL_MS = C.TIME.minutes(5);
 var DEFAULT_MAX_SNAPSHOT_BYTES   = C.BYTES.mib(50);
 var SCHEMA_VERSION               = 1;
-var SNAPSHOT_ID_RAND_BYTES       = 8;                                                                 // allow:raw-byte-literal — snapshot-id random suffix
+var SNAPSHOT_ID_RAND_BYTES       = 8;                                                                 // snapshot-id random suffix
 
 /**
  * @primitive b.agent.snapshot.create

package/lib/vendor/blamejs/lib/agent-stream.js

@@ -66,7 +66,7 @@ var audit             = lazyRequire(function () { return require("./audit"); });
 
 var AgentStreamError = defineClass("AgentStreamError", { alwaysPermanent: true });
 
-var DEFAULT_BATCH_SIZE = 256;                                                                          // allow:raw-byte-literal — cursor batch row count, not bytes
+var DEFAULT_BATCH_SIZE = 256;                                                                          // cursor batch row count, not bytes
 
 /**
  * @primitive b.agent.stream.create

package/lib/vendor/blamejs/lib/agent-tenant.js

@@ -121,7 +121,7 @@ var TENANT_KDF_LABEL = "blamejs.agent.tenant/v1";
 // 32 bytes — XChaCha20-Poly1305 key length. Distinct from the audit
 // truncation buffer so future key-length bumps don't have to chase a
 // magic constant.
-var TENANT_KEY_BYTES = 32;                                                                              // allow:raw-byte-literal — XChaCha20-Poly1305 key length (256 bits)
+var TENANT_KEY_BYTES = 32;                                                                              // XChaCha20-Poly1305 key length (256 bits)
 
 /**
  * @primitive b.agent.tenant.create

package/lib/vendor/blamejs/lib/agent-trace.js

@@ -78,7 +78,7 @@ function _emitFirstFailureAudit(auditImpl, kind, message) {
   if (_failureAuditEmittedFor[kind]) return;
   _failureAuditEmittedFor[kind] = true;
   agentAudit.safeAudit(auditImpl, "agent.trace.tracer_failure", null, {
-    kind: kind, message: message ? String(message).slice(0, 256) : "",                                  // allow:raw-byte-literal — audit-message char cap
+    kind: kind, message: message ? String(message).slice(0, 256) : "",                                  // audit-message char cap
     rateLimited: "first-occurrence-only",
   });
 }
@@ -249,8 +249,8 @@ function _shouldSample(globalRate, perMethod, method, traceId) {
     // Use the low 32 bits of the trace-id as the sampling roll
     // (W3C-compatible). Hash modulo 1e9 → divide by 1e9 puts the
     // result in [0,1) deterministically.
-    var lo = parseInt(traceId.slice(-8), 16);                                                          // allow:raw-byte-literal — low 32 bits of trace-id hex
-    var roll = (lo >>> 0) / 0x100000000;                                                                // allow:raw-byte-literal — 2^32 normalization divisor
+    var lo = parseInt(traceId.slice(-8), 16);                                                          // low 32 bits of trace-id hex
+    var roll = (lo >>> 0) / 0x100000000;                                                                // 2^32 normalization divisor
     return roll < rate;
   }
   // No trace-id supplied — start of a new trace. Operators wire

package/lib/vendor/blamejs/lib/ai-capability.js

@@ -74,7 +74,7 @@ var REASONING_TIERS = ["none", "basic", "standard", "advanced"];
 // descriptor fields are costPer1kInputTokens / costPer1kOutputTokens).
 // Dividing a token count by this rate unit converts a per-1k rate into
 // the per-token multiplier — a rate denominator, not a byte size.
-var COST_RATE_TOKEN_UNIT = 1000;   // allow:raw-byte-literal — per-1k-token cost-rate denominator, not a byte count
+var COST_RATE_TOKEN_UNIT = 1000;   // per-1k-token cost-rate denominator, not a byte count
 
 var DESCRIPTOR_KEYS = [
   "maxContextTokens", "maxOutputTokens", "modalitiesIn", "modalitiesOut",

package/lib/vendor/blamejs/lib/ai-dp.js

@@ -73,7 +73,7 @@ var ACCOUNTINGS = ["basic", "rdp"];
 // integer-exact discrete-Gaussian sampler. 2^32 keeps the deviation
 // from the target σ² below 2^-32 — far under the noise scale — while
 // keeping the BigInt denominators bounded.
-var SIGMA2_RATIONAL_DEN = 4294967296;          // allow:raw-byte-literal — 2^32 rational-approx denominator, not a byte size
+var SIGMA2_RATIONAL_DEN = 4294967296;          // 2^32 rational-approx denominator, not a byte size
 
 // ---- Minimal exact rational (BigInt num / den, den > 0) ----
 
@@ -105,7 +105,7 @@ function _uniformBelow(m) {
   if (m <= 0n) throw new AiDpError("ai-dp/internal", "ai.dp: _uniformBelow needs m > 0");
   if (m === 1n) return 0n;
   var bits = m.toString(2).length;
-  var bytes = Math.ceil(bits / 8);                        // allow:raw-byte-literal — bits-per-byte divisor, not a size
+  var bytes = Math.ceil(bits / 8);                        // bits-per-byte divisor, not a size
   var mask = (1n << BigInt(bits)) - 1n;
   for (;;) {
     var buf = bCrypto.generateBytes(bytes);
@@ -121,7 +121,7 @@ function _uniformBelow(m) {
 // the BigInt rejection sampler (accumulating 53 bits in a JS Number
 // would overflow the 2^53 safe-integer range and skew the draw), then
 // mapped (val + 1) / 2^53 → (0, 1].
-var TWO_POW_53 = 9007199254740992;                         // allow:raw-byte-literal — 2^53 mantissa range, not a byte size
+var TWO_POW_53 = 9007199254740992;                         // 2^53 mantissa range, not a byte size
 function _uniformOpen() {
   var v = Number(_uniformBelow(9007199254740992n));        // [0, 2^53) exact
   return (v + 1) / TWO_POW_53;                             // (0, 1]
@@ -231,7 +231,7 @@ function _snappingLaplace(value, scale, bound) {
 
 // ---- Rényi-DP costs (Mironov 2017) ----
 
-var RDP_ORDERS = [1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5, 6, 8, 12, 16, 24, 32, 48, 64, 128, 256];   // allow:raw-byte-literal — Rényi DP orders (α), not byte sizes
+var RDP_ORDERS = [1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5, 6, 8, 12, 16, 24, 32, 48, 64, 128, 256];   // Rényi DP orders (α), not byte sizes
 
 // Gaussian mechanism with noise-to-sensitivity z = sigma / sensitivity:
 // RDP(alpha) = alpha / (2 z^2).

package/lib/vendor/blamejs/lib/ai-input.js

@@ -25,8 +25,8 @@ var numericBounds = require("./numeric-bounds");
 var audit = require("./audit");
 var { AiInputError } = require("./framework-error");
 
-var SAMPLE_TRUNC = 80;                                                                       // allow:raw-byte-literal — sample truncation length, not bytes
-var CONFIDENCE_BASE = 60;                                                                    // allow:raw-byte-literal — confidence percentage base / allow:raw-time-literal — not seconds
+var SAMPLE_TRUNC = 80;                                                                       // sample truncation length, not bytes
+var CONFIDENCE_BASE = 60;                                                                    // allow:raw-time-literal — not seconds
 
 var PATTERNS = [
   { id: "ignore-prior-instructions", severity: 3, re:
@@ -44,7 +44,7 @@ var PATTERNS = [
   { id: "exfil-callback",            severity: 3, re:
     /\b(?:send|post|fetch|exfil|leak|paste|forward)\b[\s\S]{0,40}(?:secret|key|token|password|cred|env|\.ssh|private)/i },
   { id: "base64-marker-around-instructions", severity: 2, re:
-    /(?:[A-Za-z0-9+/]{40,}={0,2})\s+(?:means|decodes?\s+to|=)/i },                          // allow:raw-byte-literal — regex repetition floor, not bytes
+    /(?:[A-Za-z0-9+/]{40,}={0,2})\s+(?:means|decodes?\s+to|=)/i },                          // regex repetition floor, not bytes
   { id: "rot13-shape",               severity: 2, re:
     /\b(?:rot13|rotcipher|cipher|caesar)\s*[:=]\s*[a-zA-Z]{20,}/i },
   { id: "markdown-injection",        severity: 2, re:
@@ -138,7 +138,7 @@ function classify(input, opts) {
     else if (signals[j].severity === 2) sev2++;
   }
   var verdict = sev3 > 0 ? "malicious" : (sev2 >= 2 ? "suspicious" : "clean");
-  var confidence = sev3 === 0 && sev2 === 0 ? 0 : Math.min(100, CONFIDENCE_BASE + sev3 * 15 + sev2 * 5);                                // allow:raw-byte-literal — confidence ceiling 100, not bytes/seconds
+  var confidence = sev3 === 0 && sev2 === 0 ? 0 : Math.min(100, CONFIDENCE_BASE + sev3 * 15 + sev2 * 5);                                // confidence ceiling 100, not bytes/seconds
 
   if (auditOn && verdict !== "clean") {
     audit.safeEmit({