@blamejs/core 0.15.12 → 0.15.14

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.15.x
 
+- v0.15.14 (2026-06-20) — **A broad security-hardening release: every request-IP trust decision is peer-gated against the immediate connection (closing an X-Forwarded-For spoofing class — one behavior change, see Migration), a wide set of authentication and signature verifiers now fail closed, pre-auth parsers are hardened against algorithmic-complexity and frame-desync attacks, and untrusted-key allowlist lookups, at-rest encryption binding, and on-disk writes are tightened framework-wide; adds streaming and exclusive atomic-write primitives, a script-context JSON serializer, and HTTP-client bandwidth throttling.** This release tightens existing protections across the framework rather than adding opt-ins. The headline behavior change is how the client IP is trusted: the IP gates that make security decisions (network allowlist, rate limiter, break-glass grant pin) no longer trust a bare leftmost X-Forwarded-For value when trustProxy is set without an explicit proxy allowlist — they resolve the client IP by a peer-gated right-to-left walk anchored at the connecting socket, so a direct caller can no longer forge an allowed address. Operators who terminate behind a proxy now declare its address range in trustedProxies (see Migration). Alongside that, a large set of verifiers that could accept a malformed or unsigned credential now fail closed (SAML audience restriction, FDA electronic-signature, SD-JWT key-binding replay, DPoP, CIBA, mdoc trust anchor, COSE algorithm/curve binding, agent-snapshot plaintext under a regulated posture); pre-authentication parsers that an attacker reaches before any credential check are hardened against quadratic-time and frame-desync denial of service (CBOR, JSONPath, tar/PAX, gzip, YAML, ASN.1 DER, the scheduler's timer math); allowlist and posture lookups keyed by untrusted input can no longer reach Object.prototype; the framework's own file writes are now symlink-refusing and atomic; at-rest and egress paths bind ciphertext to its location and redact nested secrets; and several lost-update races are serialized. New surface is additive: streaming and exclusive atomic-write primitives, a serializer safe to embed in an inline <script>, and download/upload bandwidth throttling on the HTTP client. **Added:** *b.atomicFile.writeStream(filepath, source, opts?) and b.atomicFile.writeExclSync(filepath, data, opts?)* — Two atomic-write primitives that complete the read-side fdSafeReadSync family. writeStream writes a stream to a fresh O_EXCL|O_NOFOLLOW temporary file with an output-byte cap, then renames into place; writeExclSync stages a synchronous write through a verify-then-rename (clearing any stale temp under O_EXCL|O_NOFOLLOW first) for the small sealed-state round-trips (vault seal / unseal / rotate). Both refuse to follow a symlink at the destination or temp path, so an attacker who pre-creates a link can't redirect the write. The framework's own predictable-temp and symlink-following write sites now route through them; fdSafeReadSync also gains a withStat option that returns the bound fd's stat alongside the bytes. · *b.safeJson.stringifyForScript(value, opts?)* — A JSON serializer safe to embed directly in an inline <script> block: it escapes <, >, and & and the U+2028 / U+2029 line separators so a value containing </script> or a JS line terminator cannot break out of the script context (DOM-XSS). The import-map helper gains scriptTag(importMap, { nonce }) built on it, and the speculation-rules inline emitter uses it. · *HTTP-client bandwidth throttling* — b.httpClient requests accept a bandwidth limit that interposes a throttling transform on both the download and upload paths, so a large transfer can be rate-shaped without buffering the whole body. Useful for bounding the egress a single outbound call can consume. · *Incremental audit-chain verification* — The audit verifiers accept a from/to range so a long chain can be verified in increments rather than head-to-tail every time, report an accurate rowsVerified count, and keep the newest review when reconciling. b.vault also exposes getDefaultStore() for callers that need the process's default seal/unseal store handle. **Changed:** *DORA major-incident reporting clock is four hours* — The Digital Operational Resilience Act initial-notification deadline is corrected to four hours from classification (it had used the generic 24-hour default), incident classification weighs the affected-client-base percentage, and the deadline anchors to the prior filing where one exists. · *Range and conditional-request correctness* — Compression skips a 206 Partial Content or any Content-Range response (RFC 7233 §4.1), so it can't drop Content-Length over a now-compressed byte interval; static-file conditional handling gives If-None-Match precedence over If-Modified-Since and If-Match over If-Unmodified-Since (RFC 7232); and the object store honors the [start, end] array range contract that previously fell through to a full read. · *Declared request bodies are always validated* — A route that declares a body schema now validates it even when no body was parsed, so an omitted required body is rejected at the router instead of reaching the handler — mirroring the always-run params and query checks. **Fixed:** *Object store getStream works on remote backends* — getStream() returned a stream wrapping an unresolved promise on every remote backend, so it never delivered bytes; it now resolves the object before streaming. · *Queue and body-parser correctness* — The local queue's fail()/complete() paths guard on the current row status so a stale lease can't resurrect or double-process a job, and the body parser's raw() mode no longer matches every content type by default (it had answered 415 to nothing or everything depending on the wildcard). · *Sanctions screening and GraphQL SDL probing no longer under-match* — Sanctions screening no longer skips a candidate whose type doesn't match the query's type filter (a sanctioned entity of an unspecified type was missed) and reports a typeMatch flag; the GraphQL federation guard probes for the _service / _entities introspection fields by word boundary (an aliased field bypassed the prefix check) and over batched-array request bodies. The per-tenant query budget is a true sliding window, so a burst straddling the window boundary can't briefly double the rate. **Security:** *Request-IP trust is peer-gated end to end* — The client-IP resolution that every IP gate depends on is extracted into one trust model (a trustedProxies-aware, peer-gated right-to-left walk) so the network allowlist, rate limiter, break-glass pin, and bot-guard audit attribution all decide identity the same way. X-Forwarded-Proto is peer-gated across the security middleware on the same model, and a WebSocket reconnect to a swapped target is re-validated against the SSRF / blocked-host guard before the connection is reused. See Migration for the one behavior change. · *Authentication and signature verifiers fail closed* — A set of verifiers that could accept a malformed or unsigned credential now refuse it: SAML verifyResponse fails closed on a missing AudienceRestriction or unparseable Conditions; the FDA 21 CFR 11 electronic-signature verify refuses a record with no signature (recordHash alone is self-consistency, not authentication); the SD-JWT key-binding JWT requires an audience and nonce (replay binding) and an expiry when configured; DPoP cross-checks the proof's alg against its embedded JWK key type before importing it; CIBA verifies the ID token on poll and notification; the mdoc trust anchor is enforced (no fail-open); COSE binds the signature algorithm to the key curve; and agent-snapshot refuses allowPlaintext under a regulated compliance posture and gates sealing on vault initialization. · *Pre-auth parsers hardened against complexity and frame-desync denial of service* — Parsers an attacker reaches before any credential check are bounded. CBOR rejects the quadratic-time duplicate-map-key construction (it ran O(n^2) on every COSE / CWT / EAT / mdoc verify) and rejects non-minimal integer/key encodings in canonical mode; JSONPath caps the node-list cross-product that could exhaust memory and rejects the filter expression that could overflow the parser stack; the tar reader caps a random-access entry read and resynchronizes a PAX header whose size field is non-numeric; the gzip reader caps a random-access output size; the YAML scanner replaces a backtracking pattern with a linear scan; the ASN.1 DER reader caps high-tag-number and OID sub-identifier decoding and rejects non-minimal forms; and the scheduler clamps far-future timers so a 32-bit overflow can't make a timer fire immediately or an interval tight-loop. · *Allowlist and posture lookups keyed by untrusted input can't reach the prototype* — Lookups of the form map[untrustedKey] across the framework's allowlist and compliance-posture tables are now own-property checks, so a key like __proto__ or constructor resolves as absent instead of returning an inherited value and walking the gate (CWE-1321). The shared posture-accessor that several guards built by hand is centralized, and an inverse detector flags any re-introduced unguarded indexed lookup. · *Framework file writes are symlink-refusing and atomic* — The predictable-temp and symlink-following write sites (cookie jar, config-drift snapshot, archive extraction, local object store, backup bundle, and the vault passphrase seal/unseal/rotate) now write through the atomic-write primitives above, so a pre-planted symlink at the destination or temp path can no longer redirect a privileged write, and a partial write can't leave a torn file. A re-introduced raw write without the exclusive/no-follow flags is flagged by a detector. · *X.509 issuer chains enforce the CA basic constraint* — Node's checkIssued() does not verify that the issuer certificate is actually a CA (CVE-2002-0862 class), so a leaf signed by a non-CA certificate could be accepted as an issuer. Certificate-chain walking is centralized in one helper that requires the issuer's basicConstraints cA bit and verifies the signature, and every chain consumer (TSA, BIMI, S/MIME, mdoc, content-credentials, the FIDO MDS3 anchor match) routes through it. · *Header, value, and markup injection closed* — Mail rejects CRLF in Reply-To and in custom header keys/values (SMTP header injection); the GDPR data-export CSV writer neutralizes formula-injection prefixes; the content guards decode no-semicolon numeric HTML entities when revealing a dangerous URL scheme (so &#106;avascript: is caught); the early-hints emitter rejects CRLF in pushed link values; the HTML/SVG/BIMI comment scanners honor the WHATWG abrupt-comment-close forms (--!>, <!-->) so a mutation-XSS comment can't smuggle markup; and the CSP builder no longer emits a host source alongside 'none'. · *At-rest and egress data is bound to its context* — Backup restore binds each encrypted file blob to its manifest path as additional authenticated data, so a blob remapped to another entry fails the AEAD tag on restore (signed and unsigned bundles alike), and threads the signature-verification options through extraction; the data-subject-request lookup dual-reads the keyed and legacy subject hashes so a subject is still found across the hashing change (GDPR Art. 17); the log redactor collapses a secret nested as an array or object value, not only as a scalar; and the OTLP exporter redacts the span name and status message, not just attributes, before they leave the process. · *Network-protocol verification hardened* — OCSP responses are bound to the requested certificate serial; the WebSocket reader rejects reserved opcodes and reserved bits; the DNS parser refuses a record that reads past the message buffer; the NTP client rejects a reply whose origin timestamp does not echo the request (and the SNTP cookie path was reworked to bind the exchange); DANE TLSA matching is constant-time; and MTA-STS policy fetch fails closed rather than degrading to no-policy on an ambiguous response. · *Byte caps are measured in bytes, and middleware enforcement is per-instance* — Size limits that compared a byte budget against a string's character length (so multibyte input slipped a ~2-4x looser bound) now measure actual bytes — guard-json per-string cap, the per-tenant quota header budget, the JMAP request cap. The CSRF and fetch-metadata middleware track their gate per instance, so mounting a second, stricter instance still enforces (a shared request flag previously let the first, lenient mount disable it); the CSRF cookie is still issued once per response. The WebAssembly global is stripped from the sandbox worker so sandboxed code cannot JIT around the isolation. · *Lost-update races serialized* — Concurrent failure recording in the login lockout and bot-challenge gates is serialized per key, so parallel failed attempts can no longer each read the same pre-write counter and stay under the lockout / challenge threshold. The inline webhook delivery is claimed before the POST so a concurrent retry pass can't double-send it, and a transient transport failure now backs off and retries instead of being dead-lettered. **Migration:** *X-Forwarded-For trust now requires an explicit proxy allowlist* — The IP gates that enforce a security decision — network allowlist, rate limiter, and the break-glass grant IP pin — previously resolved the client IP from the leftmost X-Forwarded-For value whenever trustProxy was truthy. A direct caller could set that header to any address and walk an IP allowlist or evade a rate-limit key (CWE-290 / CWE-348). These gates now fail closed: with trustProxy set but no trustedProxies, they ignore X-Forwarded-For and use the connecting socket's peer address. To keep trusting a forwarded client IP, set trustedProxies to the CIDR(s) of your front proxy/load balancer — the client IP is then resolved by a peer-gated right-to-left walk that stops at the first hop not in the allowlist. For an allowlist / rate-limit / break-glass gate the new default is stricter (it trusts less), so an operator who has not migrated sees tighter enforcement, never looser. Display-only consumers (error pages, request logs) keep the lenient resolution and carry a docstring warning. The wiki example's WIKI_TRUST_PROXY flag is replaced by WIKI_ADMIN_TRUSTED_PROXIES (a CIDR list).
+
+- v0.15.13 (2026-06-19) — **Consolidates a large set of duplicated, security-sensitive code paths — injected-dependency validation, positive-integer option caps, TOCTOU-safe file reads, markup escaping, audit emission, structured-field parsing, and untrusted-JWK import — onto shared hardened primitives, so a fix or guard now applies everywhere at once; adds a TOCTOU-safe file reader; and makes several configuration errors throw typed framework errors instead of a bare Error.** Across the framework, logic that had been hand-rolled in many places (and had quietly drifted between copies) is now single-sourced through shared primitives. The practical effect for operators is consistency: the strongest available guard is applied everywhere a given operation happens, rather than in whichever copy happened to have it. Injected dependencies (stores, backends, vaults, db handles, query objects) are validated through one contract; operator-tunable positive-integer options (pool sizes, byte caps, timeouts, stream limits) validate through one bounds primitive that forwards the caller's non-retryable / HTTP-status flags; the open-fd → fstat → read-fully pattern that several call sites used to defend file reads against a swap-after-stat race (CWE-367) is now the b.atomicFile.fdSafeReadSync primitive, with symlink refusal, inode-equality, a byte cap, and an integrity hash available as options and each caller's exact typed error preserved; and the XML/HTML markup escapers (including the b.guardHtml / b.guardSvg sanitizer output) route through one b.markupEscape so the base & < > " chain can't drift between them. A few configuration-validation paths that threw a bare Error (httpClient.configurePool, b.db stream-limit validation) now throw the module's typed framework error. No security defaults change; this release tightens and unifies existing protections rather than adding opt-ins. **Added:** *b.atomicFile.fdSafeReadSync(filepath, opts?)* — A TOCTOU-safe synchronous file read (CWE-367 / js/file-system-race): it opens the path read-only, then binds the size, content, and integrity measurement to the inode the fd holds open, so a swap between stat and read can't change which bytes are returned. Optional guards layer on top — maxBytes (refuse an over-cap file), refuseSymlink + inodeCheck (refuse a symlink source and any inode swap, the strongest posture for operator-writable paths), expectedHash (SHA3-512), encoding (return a string), allowShortRead — and an errorFor(kind, detail) callback lets each caller keep its own typed error. The framework's own file reads (atomic-file, the TLS certificate-path loader, the sealed-PEM source reader, the backup bundle reader) all route through it. · *Shared substrate primitives for previously-duplicated logic* — A set of shared primitives now back call sites that had each re-implemented the same logic: validateOpts.requireMethods (gains a `permanent` flag) for injected-dependency contract checks; numericBounds positive-finite-int validators (gain an errorOpts { permanent, statusCode }) for tunable integer options; b.markupEscape for the & < > " markup chain; structured-field parsing helpers (parseTagList, forEachKeyValue, splitUnquoted, stripDoubleQuotes, unfoldHeaderContinuations); crypto.importPublicJwk and crypto.makeBase64UrlDecoder; safeSql.toPositional; safeBuffer.makeByteCoercer; nonceStore.enforceReplay; and the audit/observability namespaced emitters. These are mostly invisible substrate — the operator-visible benefit is that a guard or fix added to one of them now covers every caller. **Changed:** *Configuration errors throw typed framework errors* — Two configuration-validation paths that threw a bare `Error` now throw the module's typed framework error: httpClient.configurePool (bad maxSockets / maxFreeSockets / keepAliveMsecs → HttpClientError, code httpclient/bad-opts) and the b.db stream-limit validation (Query.stream → DbQueryError). The thrown error remains an Error subclass, so existing `instanceof Error` / try-catch handling is unaffected; code that matched the old free-text message should match the typed error's `code` instead. Several routed validators also report a slightly more precise message ("positive finite integer" instead of "positive integer"). **Fixed:** *Webhook deliveries retry transient transport failures instead of dead-lettering them* — A delivery that failed with a transient transport error (connection reset, timeout, 5xx) was recorded as permanently failed and dead-lettered rather than retried. The destination-safety check (SSRF / blocked-host guard) now runs in its own step and is the only permanent failure; a transport failure backs off and retries up to the configured limit. · *Webhook deliveries table creates on MySQL* — The pending-delivery index used a partial-index (WHERE) clause that MySQL does not support, so the deliveries table failed to create on a MySQL backend. The index is now dialect-aware — partial on PostgreSQL / SQLite, plain on MySQL. · *Inline webhook delivery can't be double-sent by concurrent retry processing* — An inline delivery is now claimed (status set to in-flight with a claim timestamp) before the POST, so a concurrent retry pass can't pick up and re-send the same delivery; a row left in-flight by a crash is reclaimed after the stale-claim window. · *Audit checkpoint can never be anchored against a replaced database* — close() fires a best-effort final checkpoint as the database shuts down. In a narrow close-then-reopen window that checkpoint's write could resume after a fresh database had opened and anchor the prior database's chain tip into it. checkpoint() now binds to the database it read the tip from and refuses to write (returns null, fail-closed) if that handle has since been closed or replaced — so a checkpoint is only ever written against the database it measured. **Security:** *TOCTOU-safe file reads applied uniformly* — The open-fd → fstat → read pattern that anchors a file read to one inode against a swap-after-stat race is now centralized in b.atomicFile.fdSafeReadSync, and every framework file read routes through it. The sealed-PEM source reader keeps the strongest posture (symlink refusal + inode-equality + byte cap), and those guards are now available as options to any caller — a re-introduced hand-rolled read-loop is flagged by a codebase-pattern detector. · *Injected-dependency and integer-option validation can't silently drift* — Injected stores / backends / vaults / db handles / query objects are validated through one contract (validateOpts.requireMethods), and operator-tunable positive-integer options through one bounds primitive (numericBounds), both forwarding the caller's non-retryable / HTTP-status error flags so a config error stays permanent / carries its 4xx. Inverse detectors flag any re-introduced inline check, so the validation can no longer be partially copied or weakened in one place. · *Single markup-escape chain for the HTML/SVG sanitizers* — The b.guardHtml and b.guardSvg sanitizer output escapers, the AI-Act transparency and mail HTML escapers, and the XML report escapers now share one b.markupEscape for the base & < > " chain (apostrophe form as a parameter; each caller keeps its own input coercion and any extra escapes such as guardHtml.escapeAttr's backtick / = IE-attribute-injection hardening). Byte-for-byte parity with the prior escapers was verified across an XSS-vector corpus, so the consolidation cannot have introduced an escaping gap; a re-inlined & < > " chain anywhere else is flagged by a detector. · *One hardening point for untrusted public-JWK import* — The createPublicKey-from-JWK call that imports attacker-controlled key material (DID publicKeyJwk, DNSKEY, COSE_Key, DPoP / OAuth / OIDC / DBSC proof JWKs) is centralized in b.crypto.importPublicJwk, so the untrusted-key import has a single audited home; each caller keeps its own kty/crv pre-validation and typed error. · *Linear-time Content-Security-Policy header parsing* — The CSP response-header parser split directives on a `/\s*,\s*/` regex that ran in O(n^2) on a long comma-less run of whitespace, letting a crafted header stall a worker (js/polynomial-redos). It now splits on the literal comma and trims each item, which is linear and byte-for-byte equivalent. · *Parsed INI and OpenAPI path maps can't reach Object.prototype* — The INI parser already refuses a `__proto__` / `constructor` / `prototype` section or key (it throws before any write); as defense-in-depth, every parsed node — and the OpenAPI paths map keyed by URL pattern — is now a null-prototype object, so even a future gap could only ever set an own property, never mutate Object.prototype (CWE-1321).
+
 - v0.15.12 (2026-06-14) — **Hardens a set of defense-in-depth seams: a single-pass structured-field unescape, a constant-time content-digest member match, complete reserved-character stripping, a Trojan-Source escape on the boot logger, generic body-parse error responses, and an audit trail whenever outbound TLS certificate validation is disabled.** A sweep of low-severity but real hardening items. RFC 8941 structured-field string values (HTTP Message Signatures, Client Hints, Cache-Control) were un-escaped with two chained replaces that mis-decoded an escaped backslash adjacent to another escape; they now use one left-to-right pass that decodes each escape exactly once. The HTTP Message Signature content-digest check dropped a dead identity-replace and now matches the sha3-512 member by an exact, top-level, constant-time comparison instead of an unanchored substring scan. b.guardFilename's reserved-character strip used a non-global regex that left every separator after the first; it now strips all of them. The boot logger's TTY branch wrote raw text, bypassing the Trojan-Source / control-character escape the main logger applies — it now escapes the bidi and C0/newline control classes on every sink. The body parser no longer echoes a caught exception's detail (an fs errno + temp path, or a parse hook's thrown message) to the HTTP client — the client gets a generic status phrase while the full detail stays on the audit chain. And any outbound TLS connection that runs with peer-certificate validation disabled (an explicit operator opt-in, never a default) now emits a tls.insecure_skip_verify audit + observability event so the degraded posture is visible for compliance and incident response. **Added:** *b.structuredFields.unescapeSfStringBody(body)* — A single-pass decode of the RFC 8941 §3.3.3 quoted-string backslash escapes (the bytes between the surrounding quotes). It replaces the chained two-`.replace()` form, which is not equivalent to one decode — whichever pass runs first can rewrite a backslash the other escape sequence owns, so a lone escaped backslash decoded to two. The HTTP Message Signature, Client Hints, and Cache-Control sf-string readers now route through it. · *tls.insecure_skip_verify audit event* — b.network.tls.auditInsecureTls(meta) emits an audit + observability event at the point an outbound TLS connection honors rejectUnauthorized:false / allowInsecure. The connectWithEch, OTLP-gRPC log stream, syslog-TLS log stream, and SMTP transports all emit it when an operator disables certificate validation — parallel to the existing tls.classical_downgrade audit. No default changes; the framework never disables validation itself. **Security:** *Single-pass structured-field string unescape* — The RFC 8941 sf-string readers in HTTP Message Signatures (Signature-Input covered-component names), Client Hints, and Cache-Control directive values un-escaped with `.replace(/\\\\/g,"\\").replace(/\\"/g,'"')` — two sequential passes that mis-decode adjacent escapes (a lone escaped backslash became two). All four sites now use the single-pass b.structuredFields.unescapeSfStringBody. It is fail-closed (a mis-decoded covered-component name just fails the signature check, never bypasses it); the fix restores RFC-conformant interop with peers that legitimately escape these values. · *Constant-time, member-anchored content-digest verification* — b.crypto.httpSig.verify's covered content-digest check dropped a dead no-op replace and now parses the Content-Digest header into its top-level members and matches the sha3-512 member EXACTLY, in constant time (b.crypto.timingSafeEqual), rather than scanning for the digest text as a substring anywhere in the header. The Content-Digest header is already bound by the signature, so the substring form was not reachably exploitable; the change removes the latent ambiguity and the timing channel. · *Reserved-character filename strip removes every occurrence* — b.guardFilename's reservedCharPolicy:"strip" (the permissive profile) used a non-global regex, so only the FIRST reserved character — including path separators — was replaced and the rest leaked through. The strip is now global: every reserved character is removed. Not a traversal bypass (the unconditional security floor still throws on `..`, null bytes, NTFS ADS, UNC, overlong UTF-8), but the strip is now complete and consistent. · *Boot logger escapes control + bidi characters on every sink* — The boot-time logger's TTY branch wrote the raw message, bypassing the Trojan-Source (bidi) and control-character escapes the main logger applies — a hostile message could forge extra log lines on a terminal (CWE-117) or re-order the visible line (CVE-2021-42574). Both boot branches now escape the bidi and C0/newline control classes, matching the create() path and the logger's advertised guarantee. · *Body-parser error responses never echo internal detail* — The body-parser's terminal error path surfaced a caught exception's message verbatim to the HTTP client — a multipart filesystem error leaked the errno + temp path, and a parse hook's thrown error (which can carry secrets) was echoed back. The client now gets a curated message only for a framework-classified 4xx error and a generic status phrase otherwise; the parse-hook wrapper carries a fixed message, and full diagnostics stay on the audit chain server-side (CWE-209). The cluster leader-discovery endpoint's error body is generalized the same way.
 
 - v0.15.11 (2026-06-14) — **Replaces a family of quadratic-time regexes that hostile input could use to stall a worker with linear scans, refuses a relocatable sealed-cell downgrade on the read side, fails closed when enabling row-level security behind a non-native driver, and scans the vendored crypto for known CVEs on every build.** Several text-handling primitives stripped trailing whitespace or extracted a mail address with a regex whose backtracking is quadratic in the input length on adversarial strings — a request body, a YAML document, a CSV cell, or a From header crafted as a long run of spaces could pin a worker's CPU. Each is now a linear character scan with identical output. The HTML-content check the MCP tool surface applies gained the vbscript: and data:text/html vectors it was missing. On the data-at-rest side, an AAD-bound (or per-row-key) column now refuses a plain, unbound vault cell on read — a relocatable envelope an attacker with write access could copy in from another row defeats the cross-row binding, so the field is nulled rather than surfaced; operators mid-migration opt back in with registerTable({ allowPlainMigration: true }). declareRowPolicy now treats row-level-security as enabled only on a value that unambiguously means true, so a non-native Postgres driver that returns the string "f" can no longer be read as "already on" and silently skip the ENABLE that protects the table's rows. Finally, because the framework's crypto is vendored rather than installed, npm audit and Dependabot never see it: every build now matches the vendored versions against the OSV vulnerability database, with a complementary Semgrep pass and workflow-file static analysis alongside. **Added:** *b.safeBuffer.indexAfterOpenTag(html, tagName)* — A linear helper that returns the offset just past a `<tag ...>` opening tag (case-insensitive), or -1 when absent or unterminated — the insertion point a response rewriter uses to splice content after <body> or <head> without a regex. It replaces the O(n^2) html.match(/<body[^>]*>/i) shape and is stricter than it: a real tag boundary is required after the name, so <bodyfoo> is not mistaken for <body>. **Security:** *Linear-time replacements across a family of quadratic regexes (ReDoS class)* — Several primitives located or stripped text with a regex whose backtracking is quadratic in V8 on adversarial input (CWE-1333): b.safeBuffer and the safe-env / safe-yaml / guard-csv parsers stripped trailing horizontal whitespace with /[ \t]+$/; b.mail extracted the address from a `Name <addr>` header with /<([^>]+)>/; the bot-disclosure and speculation-rules response middleware found the <body> insertion point with /<body[^>]*>/i; and the BIMI certificate-chain splitter walked PEM blocks with a lazy /BEGIN[\s\S]*?END/ scan. A crafted field — a long run of spaces, an unterminated bracket, a body carrying many <body starts with no closing >, a chain of BEGIN markers — could drive a worker's CPU to seconds of work. Each is now a linear scan: a shared b.safeBuffer.stripTrailingHspace (backward char walk), b.safeBuffer.indexAfterOpenTag (forward indexOf walk for the tag insertion point), a forward indexOf for address extraction, and an indexOf walk for the PEM split. Output is byte-identical (the tag-find is stricter — it no longer mistakes <bodyfoo> for <body>), and 400K-character adversarial inputs that took 8–85 seconds now complete in under 2 ms. · *MCP HTML-content check covers vbscript: and data:text/html* — The dangerous-markup check applied to text/html tool content matched <script>/<iframe>/<object>/<embed> and javascript: URLs but not the vbscript: scheme or data:text/html payloads. Both are now refused; data: URLs carrying non-HTML media (data:image/png and similar) are unaffected. · *AAD-bound columns refuse a plain sealed cell on read* — b.cryptoField.unsealRow now refuses a plain, unbound vault: envelope found on an AAD-bound (or per-row-key) column and nulls the field instead of returning it. A plain envelope carries no per-cell binding, so a writer who could place one — copied from anywhere under the same vault root — would otherwise relocate a value across rows or columns and defeat the copy-protection the AAD binding advertises. Operators migrating pre-AAD rows up to bound ciphertext opt into a bounded acceptance window with registerTable({ allowPlainMigration: true }) and clear it when migration completes. · *Row-level-security enablement fails closed on non-native drivers* — b.db.declareRowPolicy read pg_class.relrowsecurity to skip a redundant ENABLE ROW LEVEL SECURITY, but tested it with a bare truthiness check. A native pg driver returns a JS boolean; a proxy or ORM may return the string "f" for a disabled table — and "f" is truthy, so the check read it as already-enabled and silently skipped the ENABLE, leaving every row in the table unprotected while the migration reported success. RLS now counts as enabled only on a value that unambiguously means true (true, 1, or "t"/"true"/"1"/"on"/"yes"); every other shape re-issues ENABLE, a harmless no-op on an already-enabled table. · *Vendored-crypto CVE scanning, complementary SAST, and workflow static analysis in CI* — The framework ships zero npm runtime dependencies — its crypto (the noble suite, the WebAuthn server, the PKI layer) is vendored under lib/vendor/, where npm audit, Dependabot, and Socket cannot see it. Every build now generates a CycloneDX SBOM of the vendored tree (each library carrying an npm purl) and runs it through OSV-Scanner, matching the exact pinned version against the OSV vulnerability database; a published CVE or GHSA affecting a vendored version fails the build so the copy is refreshed before merge. A Semgrep pass (registry security-audit + javascript packs at ERROR severity) runs alongside CodeQL as complementary SAST, and actionlint statically checks the workflow files. All three install the OSS tool from its upstream release, matching the existing secret-scan gate's posture. **Detectors:** *Quadratic trailing-whitespace and tag-find regex detectors* — Two codebase-pattern detectors refuse reintroduction of the quadratic shapes: the /[ \t]+$/ trailing-whitespace strip (as .replace, .test, or via the named TRAILING_HSPACE_RE export) outside the linear helper that owns it, and the str.match(/<tag[^>]*>/) document-tag find that the response middleware must route through b.safeBuffer.indexAfterOpenTag. Each is proven to fire on the removed shape and stay silent on the linear replacement, so the ReDoS class cannot creep back into a new parser, guard, or response rewriter.

package/index.js

@@ -225,6 +225,7 @@ var guardYaml = require("./lib/guard-yaml");
 var guardXml = require("./lib/guard-xml");
 var guardMarkdown = require("./lib/guard-markdown");
 var guardEmail = require("./lib/guard-email");
+var guardText = require("./lib/guard-text");
 var guardDomain = require("./lib/guard-domain");
 var guardUuid = require("./lib/guard-uuid");
 var guardCidr = require("./lib/guard-cidr");
@@ -609,6 +610,7 @@ module.exports = {
   guardXml:         guardXml,
   guardMarkdown:    guardMarkdown,
   guardEmail:       guardEmail,
+  guardText:        guardText,
   guardDomain:      guardDomain,
   guardUuid:        guardUuid,
   guardCidr:        guardCidr,

package/lib/a2a-tasks.js

@@ -51,7 +51,7 @@ var validateOpts  = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 
 var httpClient = lazyRequire(function () { return require("./http-client"); });
-var audit      = lazyRequire(function () { return require("./audit"); });
+var auditEmit  = require("./audit-emit");
 var C          = require("./constants");
 
 // A2aTasksError is the per-call error class — separate from A2aError
@@ -82,15 +82,7 @@ var TASK_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
 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
 // RFC-3986-unreserved identifier shape (length cap inside regex), not a byte count
 
-function _emitAudit(action, metadata, outcome) {
-  try {
-    audit().safeEmit({
-      action:   action,
-      outcome:  outcome || "success",
-      metadata: metadata,
-    });
-  } catch (_e) { /* best-effort */ }
-}
+var _emitAudit = auditEmit.emit;
 
 var bCrypto = lazyRequire(function () { return require("./crypto"); });
 
@@ -388,6 +380,18 @@ function middlewareTasks(opts) {
       throw new A2aTasksError("a2a-tasks/bad-mw-opts",
         "middleware.tasks: opts.scopes must be an object when provided", true);
     }
+    // Every scope VALUE must be a non-empty string. A non-string value (e.g.
+    // {transfer: ["a2a:transfer"]}) would make the runtime `typeof requiredScope
+    // === "string"` gate silently skip — a fail-open authorization bypass on a
+    // gated skill. Catch the operator typo at boot, not at request time.
+    var scopeKeys = Object.keys(opts.scopes);
+    for (var sk = 0; sk < scopeKeys.length; sk += 1) {
+      var sv = opts.scopes[scopeKeys[sk]];
+      if (typeof sv !== "string" || sv.length === 0) {
+        throw new A2aTasksError("a2a-tasks/bad-mw-opts",
+          "middleware.tasks: opts.scopes['" + scopeKeys[sk] + "'] must be a non-empty string", true);
+      }
+    }
   }
   var maxBytes = opts.maxBytes !== undefined ? opts.maxBytes : C.BYTES.mib(1);
   var emitAudit = opts.audit !== false;
@@ -437,16 +441,36 @@ function middlewareTasks(opts) {
       }
       var params = body.params || {};
 
-      // 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;                                                                    // JSON-RPC error envelope returns 200
+      // Validate the protocol identifiers on the UNTRUSTED-peer ingress before
+      // handing them to the operator handler — the client send/get/cancel
+      // dispatchers enforce these shapes on egress, the server must too (the
+      // sibling b.mcp middleware validates toolName/resourceUri identically).
+      if (body.method === "tasks/send") {
+        try { _validateTaskShape(params.task, "middleware.tasks.task"); }
+        catch (eShape) {
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(_jsonRpcError(reqId, JSONRPC_INVALID_PARAMS,
+            (eShape && eShape.message) || "tasks/send: invalid task")));
+          return;
+        }
+      } else if (body.method === "tasks/get" || body.method === "tasks/cancel") {
+        if (typeof params.taskId !== "string" || params.taskId.length > 64 || !TASK_ID_RE.test(params.taskId)) {
+          res.statusCode = 200;
           res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify(_jsonRpcError(reqId, JSONRPC_INVALID_PARAMS,
-            "tasks/send: params.task.skill required")));
+            body.method + ": params.taskId must match " + TASK_ID_RE)));
           return;
         }
-        var requiredScope = scopes[params.task.skill];
+      }
+
+      // Scope enforcement for tasks/send (task references a skill).
+      if (body.method === "tasks/send" && scopes) {
+        // Own-property lookup ONLY — an attacker-controlled skill like
+        // "constructor"/"toString" must not resolve an inherited Object.prototype
+        // member (proto-shadow). The skill shape is already validated above.
+        var hasScope = Object.prototype.hasOwnProperty.call(scopes, params.task.skill);
+        var requiredScope = hasScope ? scopes[params.task.skill] : undefined;
         if (typeof requiredScope === "string") {
           var grantedScopes = Array.isArray(req.a2aScopes) ? req.a2aScopes : [];
           if (grantedScopes.indexOf(requiredScope) === -1) {
@@ -515,19 +539,11 @@ function _jsonRpcError(id, code, message, data) {
 }
 
 function _readBody(req, maxBytes) {
-  return new Promise(function (resolve, reject) {
-    var collector = safeBuffer.boundedChunkCollector({
-      maxBytes:    maxBytes,
-      errorClass:  A2aTasksError,
-      sizeCode:    "a2a-tasks/body-too-large",
-      sizeMessage: "a2a-tasks: request body exceeded " + maxBytes + " bytes",
-    });
-    req.on("data", function (chunk) {
-      try { collector.push(chunk); }
-      catch (capErr) { reject(capErr); }
-    });
-    req.on("end", function () { resolve(collector.result()); });
-    req.on("error", function (e) { reject(e); });
+  return safeBuffer.collectStream(req, {
+    maxBytes:    maxBytes,
+    errorClass:  A2aTasksError,
+    sizeCode:    "a2a-tasks/body-too-large",
+    sizeMessage: "a2a-tasks: request body exceeded " + maxBytes + " bytes",
   });
 }
 

package/lib/acme.js

@@ -42,6 +42,7 @@
  */
 
 var nodeCrypto = require("node:crypto");
+var safeBuffer = require("./safe-buffer");
 
 var C = require("./constants");
 var asn1 = require("./asn1-der");
@@ -553,7 +554,7 @@ function create(opts) {
       var id = orderOpts.identifiers[i];
       if (!id || typeof id.type !== "string" || typeof id.value !== "string" ||
           id.type.length === 0 || id.value.length === 0 ||
-          id.value.length > C.BYTES.bytes(255)) {
+          safeBuffer.byteLengthOf(id.value) > C.BYTES.bytes(255)) {
         throw _err("acme/bad-identifier",
           "newOrder: identifier must be { type: string, value: string<=255 }", true);
       }
@@ -569,7 +570,7 @@ function create(opts) {
     // the field. v1-defensible scope: refuse non-string + cap length so
     // attacker-supplied profile values can't bloat the JSON payload.
     if (typeof orderOpts.profile === "string") {
-      if (orderOpts.profile.length === 0 || orderOpts.profile.length > C.BYTES.bytes(64)) {
+      if (orderOpts.profile.length === 0 || safeBuffer.byteLengthOf(orderOpts.profile) > C.BYTES.bytes(64)) {
         throw _err("acme/bad-profile",
           "newOrder: profile name must be a non-empty string <= 64 bytes", true);
       }
@@ -611,7 +612,7 @@ function create(opts) {
     } else {
       throw _err("acme/bad-csr", "finalize: csr must be a DER Buffer or PEM string", true);
     }
-    if (csrDer.length === 0 || csrDer.length > C.BYTES.kib(64)) {
+    if (csrDer.length === 0 || safeBuffer.byteLengthOf(csrDer) > C.BYTES.kib(64)) {
       throw _err("acme/bad-csr",
         "finalize: CSR DER size out of range (got " + csrDer.length + " bytes)", true);
     }
@@ -842,7 +843,7 @@ function create(opts) {
     }
     for (var di = 0; di < opts2.domains.length; di += 1) {
       var d = opts2.domains[di];
-      if (typeof d !== "string" || d.length === 0 || d.length > C.BYTES.bytes(255)) {
+      if (typeof d !== "string" || d.length === 0 || safeBuffer.byteLengthOf(d) > C.BYTES.bytes(255)) {
         throw _err("acme/bad-csr-domain",
           "buildCsr: domains[" + di + "] must be a non-empty string <= 255 bytes", true);
       }
@@ -1328,7 +1329,7 @@ function create(opts) {
     if (!opts2 || typeof opts2 !== "object" || typeof opts2.identifier !== "string" || opts2.identifier.length === 0) {
       throw _err("acme/bad-identifier", "dnsAccount01ChallengeRecord: opts.identifier (host) is required", true);
     }
-    if (opts2.identifier.length > C.BYTES.bytes(255)) {
+    if (safeBuffer.byteLengthOf(opts2.identifier) > C.BYTES.bytes(255)) {
       throw _err("acme/bad-identifier", "dnsAccount01ChallengeRecord: identifier exceeds 255 bytes", true);
     }
     if (!state.accountUrl) {

package/lib/agent-event-bus.js

@@ -70,6 +70,7 @@ var agentAudit            = require("./agent-audit");
 var envelopeMac           = require("./agent-envelope-mac");
 var safeJson              = require("./safe-json");
 var bCrypto               = require("./crypto");
+var boundedMap            = require("./bounded-map");
 
 var audit                 = lazyRequire(function () { return require("./audit"); });
 
@@ -149,10 +150,10 @@ function create(opts) {
 
 function _registerTopic(topics, name, topicOpts, auditImpl) {
   guardEventBusTopic.validate(name);
-  if (topics.has(name)) {
+  boundedMap.requireAbsent(topics, name, function () {
     throw new AgentEventBusError("agent-event-bus/topic-duplicate",
       "registerTopic: '" + name + "' already registered");
-  }
+  });
   if (!topicOpts.schema || typeof topicOpts.schema !== "object") {
     throw new AgentEventBusError("agent-event-bus/bad-schema",
       "registerTopic: schema required (flat key→type map)");
@@ -193,10 +194,10 @@ function _registerTopic(topics, name, topicOpts, auditImpl) {
 // lifecycle traceability.
 function _unregisterTopic(topics, name, auditImpl) {
   guardEventBusTopic.validate(name);
-  if (!topics.has(name)) {
+  boundedMap.requirePresent(topics, name, function () {
     throw new AgentEventBusError("agent-event-bus/unknown-topic",
       "unregisterTopic: '" + name + "' not registered");
-  }
+  });
   topics.delete(name);
   _safeAudit(auditImpl, "agent.event_bus.topic_unregistered", null, { name: name });
 }
@@ -421,6 +422,19 @@ async function _subscribe(topics, pubsub, name, handler, sOpts, permissions, aud
         topic: name, reason: "require-mac-disabled", phase: "delivery",
       });
     }
+    // Channel binding: the authenticated _topic must match the channel this
+    // handler was registered for. The MAC binds _topic, so a pubsub-write
+    // attacker cannot FORGE it — but they CAN replay a genuinely-MAC'd
+    // envelope from topic A onto topic B's channel. If A and B share a
+    // schema and tenant, that replay would otherwise be delivered to B's
+    // handler as a B-event. Drop on mismatch.
+    if (wrapped._topic !== name) {
+      _safeAudit(auditImpl, "agent.event_bus.delivery_dropped", sOpts.actor, {
+        topic: name, reason: "topic-channel-mismatch",
+        envelopeTopic: typeof wrapped._topic === "string" ? wrapped._topic : null,
+      });
+      return;
+    }
     // Tenant-scope check: subscriber's tenantId must match the
     // publisher's tenantId from the wire envelope. If the envelope
     // lacks _tenantId (publisher omitted), that's a tampered or

package/lib/agent-idempotency.js

@@ -143,11 +143,8 @@ function _ensureSealTable() {
 function create(opts) {
   opts = opts || {};
   var store = opts.store || _inMemoryBackend(opts.maxInMemoryEntries);
-  if (typeof store.get !== "function" || typeof store.put !== "function" ||
-      typeof store.delete !== "function") {
-    throw new AgentIdempotencyError("agent-idempotency/bad-store",
-      "create: store must expose { get, put, delete }");
-  }
+  validateOpts.requireMethods(store, ["get", "put", "delete"],
+    "create: store", AgentIdempotencyError, "agent-idempotency/bad-store");
   var ttlMs = typeof opts.ttlMs === "number" ? opts.ttlMs : DEFAULT_TTL_MS;
   if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
     throw new AgentIdempotencyError("agent-idempotency/bad-ttl",
@@ -313,7 +310,11 @@ async function _get(store, method, actorId, key, auditImpl, ttlMs, maxResultByte
   var updatedReplayCount;
   if (typeof store.incrementReplayCount === "function") {
     var updated = await store.incrementReplayCount(method, actorId, hash);
-    updatedReplayCount = updated && updated.replayCount ? updated.replayCount : (row.replayCount || 0) + 1;
+    // Coerce the store's returned count to a number — a backend that returns it
+    // as a string (some drivers stringify integer columns) would otherwise make
+    // updatedReplayCount a string and corrupt downstream arithmetic/comparison.
+    var inc = updated && updated.replayCount != null ? Number(updated.replayCount) : NaN;
+    updatedReplayCount = Number.isFinite(inc) ? inc : (Number(row.replayCount) || 0) + 1;
   } else {
     _safeAudit(auditImpl, "agent.idempotency.non_atomic_increment", null, {
       method: method, actorIdHash: _truncHash(_actorIdHash(actorId)),

package/lib/agent-orchestrator.js

@@ -157,11 +157,8 @@ var _saltedFnvBasisCache = null;
 function create(opts) {
   opts = opts || {};
   var backend = opts.backend || _inMemoryBackend();
-  if (typeof backend.get !== "function" || typeof backend.set !== "function" ||
-      typeof backend.delete !== "function" || typeof backend.list !== "function") {
-    throw new AgentOrchestratorError("agent-orchestrator/bad-backend",
-      "b.agent.orchestrator.create: backend must expose { get, set, delete, list }");
-  }
+  validateOpts.requireMethods(backend, ["get", "set", "delete", "list"],
+    "b.agent.orchestrator.create: backend", AgentOrchestratorError, "agent-orchestrator/bad-backend");
   var clusterImpl = opts.cluster || cluster();
   var auditImpl   = opts.audit   || audit();
   var permissions = opts.permissions || null;

package/lib/agent-saga.js

@@ -71,6 +71,7 @@
 
 var lazyRequire        = require("./lazy-require");
 var { defineClass }    = require("./framework-error");
+var validateOpts       = require("./validate-opts");
 var guardSagaConfig    = require("./guard-saga-config");
 var bCrypto            = require("./crypto");
 var agentAudit         = require("./agent-audit");
@@ -118,11 +119,8 @@ function create(config) {
   // `agent.saga.no_state_store` surfaces the posture per call).
   var stateStore = config.stateStore || null;
   if (stateStore !== null) {
-    if (typeof stateStore.saveStep !== "function" ||
-        typeof stateStore.loadResumePoint !== "function") {
-      throw new AgentSagaError("agent-saga/bad-state-store",
-        "create: stateStore must expose { saveStep, loadResumePoint, markCompleted?, markFailed? }");
-    }
+    validateOpts.requireMethods(stateStore, ["saveStep", "loadResumePoint"],
+      "create: stateStore", AgentSagaError, "agent-saga/bad-state-store");
   }
   return {
     run:                    function (ctx, initialState, opts) { return _run(config, auditImpl, stateStore, ctx, initialState, opts || {}); },

package/lib/agent-snapshot.js

@@ -58,6 +58,7 @@ var validateOpts          = require("./validate-opts");
 
 var audit                 = lazyRequire(function () { return require("./audit"); });
 var auditSign             = lazyRequire(function () { return require("./audit-sign"); });
+var compliance            = lazyRequire(function () { return require("./compliance"); });
 var vault                 = lazyRequire(function () { return require("./vault"); });
 
 var AgentSnapshotError = defineClass("AgentSnapshotError", { alwaysPermanent: true });
@@ -310,14 +311,40 @@ function _resolveSigner(ctx) {
     "OR pass opts.signer to b.agent.snapshot.create({ signer: { sign, verify } })");
 }
 
+// allowPlaintext is a dev / single-tenant escape hatch (no at-rest sealing,
+// and no signature required on load). It is REFUSED under a regulated
+// compliance posture so a regulated deployment cannot silently persist OR
+// restore unsealed, unsigned snapshot state. Posture is read from the
+// framework's globally-pinned source (compliance().current()) — the same
+// source the residency + cryptoField seal floors use.
+var REGULATED_NO_PLAINTEXT = ["hipaa", "pci-dss", "gdpr", "soc2"];
+function _activePosture() {
+  try { var c = compliance(); return (c && typeof c.current === "function") ? c.current() : null; }
+  catch (_e) { return null; }
+}
+function _refusePlaintextUnderPosture(action) {
+  var active = _activePosture();
+  if (active && REGULATED_NO_PLAINTEXT.indexOf(active) !== -1) {
+    throw new AgentSnapshotError("agent-snapshot/plaintext-refused-under-posture",
+      action + ": allowPlaintext is refused under the '" + active + "' compliance posture — " +
+      "wire a sealer (b.vault.init() at boot OR opts.sealer { seal, unseal }) so snapshot " +
+      "state is sealed + signature-verified at rest");
+  }
+}
+
 function _resolveSealer(ctx) {
   if (ctx.sealer) return ctx.sealer;
   var v;
   try { v = vault(); } catch (_e) { v = null; }
-  if (v && v.aad && typeof v.aad.seal === "function" && typeof v.aad.unseal === "function") {
+  // Only use the framework vault when it is actually INITIALIZED. A loaded-but-
+  // uninitialized vault still exposes aad.seal/unseal (they throw on call), which
+  // previously masked the allowPlaintext escape hatch and leaked a raw
+  // vault/not-initialized error instead of a clean sealer-not-wired refusal.
+  if (v && typeof v.isInitialized === "function" && v.isInitialized() &&
+      v.aad && typeof v.aad.seal === "function" && typeof v.aad.unseal === "function") {
     return v.aad;
   }
-  if (ctx.allowPlaintext) return null;
+  if (ctx.allowPlaintext) { _refusePlaintextUnderPosture("persist"); return null; }
   throw new AgentSnapshotError("agent-snapshot/sealer-not-wired",
     "persist: no sealer wired — operator must run b.vault.init() at boot " +
     "OR pass opts.sealer to b.agent.snapshot.create({ sealer: { seal, unseal } }) " +
@@ -526,6 +553,9 @@ async function _unwrapAndVerify(ctx, raw, expectedId) {
   // remains visible to compliance audit.
   if (typeof snap.sig !== "string" || snap.sig.length === 0) {
     if (ctx.allowPlaintext) {
+      // Even the dev escape hatch cannot waive signature verification under a
+      // regulated posture — refuse the unsigned restore rather than trust it.
+      _refusePlaintextUnderPosture("load");
       agentAudit.safeAudit(ctx.audit, "agent.snapshot.unsigned_load", null, {
         snapshotId: snap.snapshotId,
       });

package/lib/agent-tenant.js

@@ -153,11 +153,8 @@ var TENANT_KEY_BYTES = 32;
 function create(opts) {
   opts = opts || {};
   var backend = opts.backend || _inMemoryBackend();
-  if (typeof backend.get !== "function" || typeof backend.set !== "function" ||
-      typeof backend.delete !== "function" || typeof backend.list !== "function") {
-    throw new AgentTenantError("agent-tenant/bad-backend",
-      "create: backend must expose { get, set, delete, list }");
-  }
+  validateOpts.requireMethods(backend, ["get", "set", "delete", "list"],
+    "create: backend", AgentTenantError, "agent-tenant/bad-backend");
   var auditImpl   = opts.audit || audit();
   var permissions = opts.permissions || null;
   var ctx = {

package/lib/ai-adverse-decision.js

@@ -99,25 +99,12 @@ function wrap(opts) {
   var legalBasis = opts.legalBasis;
   var decide = opts.decide;
   var onAdverse = typeof opts.onAdverse === "function" ? opts.onAdverse : null;
-  var auditOn = opts.audit !== false;
   var now = typeof opts.now === "function" ? opts.now : function () { return Date.now(); };
 
   var deadlines = REGIME_DEADLINES[legalBasis] || REGIME_DEADLINES["operator-defined"];
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   "ai.adverse_decision." + action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
-  function _emitMetric(verb, n, labels) {
-    try { observability().safeEvent("ai.adverse_decision." + verb, n || 1, labels || {}); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced("ai.adverse_decision", opts.audit);
+  var _emitMetric = observability().namespaced("ai.adverse_decision");
 
   return async function adverseDecisionDecorated(subject) {
     if (!subject || typeof subject !== "object") {

package/lib/ai-aedt-bias-audit.js

@@ -36,6 +36,7 @@
  */
 
 var validateOpts = require("./validate-opts");
+var numericBounds = require("./numeric-bounds");
 var { defineClass } = require("./framework-error");
 
 var AedtBiasAuditError = defineClass("AedtBiasAuditError", { alwaysPermanent: true });
@@ -49,7 +50,7 @@ function _str(v, label) {
   return v;
 }
 function _count(v, label) {
-  if (typeof v !== "number" || !isFinite(v) || v < 0 || Math.floor(v) !== v) throw new AedtBiasAuditError("aedt/bad-count", "aedtBiasAudit: " + label + " must be a non-negative integer");
+  if (!numericBounds.isNonNegativeFiniteInt(v)) throw new AedtBiasAuditError("aedt/bad-count", "aedtBiasAudit: " + label + " must be a non-negative integer");
   return v;
 }
 

package/lib/ai-capability.js

@@ -239,12 +239,7 @@ function create(opts) {
   }
   var auditOn = opts.audit !== false;
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({ action: action, outcome: outcome, metadata: metadata || {} });
-    } catch (_e) { /* audit best-effort — drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
   function describe(modelId) {
     var d = registry.get(modelId);

package/lib/ai-content-detect.js

@@ -255,9 +255,7 @@ function report(opts) {
  * @example
  *   b.ai.aiContentDetect.compliancePosture("ca-ab-853"); // → "strict"
  */
-function compliancePosture(posture) {
-  return COMPLIANCE_POSTURES[posture] || null;
-}
+var compliancePosture = gateContract.makePostureAccessor(COMPLIANCE_POSTURES);
 
 module.exports = {
   report:               report,

package/lib/ai-dp.js

@@ -429,11 +429,7 @@ function budget(opts) {
   var spentDelta = 0;
   var rdp = RDP_ORDERS.map(function () { return 0; });   // rdp accounting
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try { audit().safeEmit({ action: action, outcome: outcome, metadata: metadata || {} }); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
   function _currentEpsilon(rdpCurve) {
     if (accounting === "basic") return spentEpsilon;

package/lib/ai-frontier-protocol.js

@@ -161,7 +161,7 @@ function frontierModelProtocol(opts) {
 function incidentReport(opts) {
   opts = opts || {};
   if (typeof opts !== "object") throw new FrontierProtocolError("frontier/bad-opts", "incidentReport: opts must be an object");
-  if (!CRITICAL_INCIDENT_TYPES[opts.type]) throw new FrontierProtocolError("frontier/bad-incident-type", "incidentReport: type must be one of " + Object.keys(CRITICAL_INCIDENT_TYPES).join(", "));
+  if (!Object.prototype.hasOwnProperty.call(CRITICAL_INCIDENT_TYPES, opts.type)) throw new FrontierProtocolError("frontier/bad-incident-type", "incidentReport: type must be one of " + Object.keys(CRITICAL_INCIDENT_TYPES).join(", "));
 
   var discoveredMs;
   if (opts.discoveredAt == null) discoveredMs = Date.now();

package/lib/ai-input.js

@@ -23,6 +23,7 @@
 var C = require("./constants");
 var numericBounds = require("./numeric-bounds");
 var audit = require("./audit");
+var codepointClass = require("./codepoint-class");
 var { AiInputError } = require("./framework-error");
 
 var SAMPLE_TRUNC = 80;                                                                       // sample truncation length, not bytes
@@ -69,8 +70,7 @@ function _featuresOf(input) {
     var cp = input.charCodeAt(i);
     if ((cp >= 0x202a && cp <= 0x202e) || (cp >= 0x2066 && cp <= 0x2069)) bidi++;
     else if (cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0xfeff || cp === 0x2060) zw++;
-    else if (cp < 0x20 && cp !== 0x09 && cp !== 0x0a && cp !== 0x0d) ctrl++;
-    else if (cp === 0x7f) ctrl++;
+    else if (codepointClass.isForbiddenControlChar(cp, { allowLf: true, allowCr: true })) ctrl++;
   }
   return {
     length:    input.length,

package/lib/ai-model-manifest.js

@@ -95,7 +95,7 @@ function _validateDataComponent(d, idx) {
       "build.datasets[" + idx + "]: must be an object");
   }
   _requireString(d, "name", "build.datasets[" + idx + "]");
-  if (d.type !== undefined && !VALID_DATA_TYPES[d.type]) {
+  if (d.type !== undefined && !Object.prototype.hasOwnProperty.call(VALID_DATA_TYPES, d.type)) {
     throw new AiModelManifestError("aibom/bad-dataset-type",
       "build.datasets[" + idx + "].type '" + d.type + "' not in CycloneDX 1.6 data-type vocabulary");
   }