@blamejs/blamejs-shop 0.1.36 → 0.1.38

package/lib/translations.js

@@ -537,10 +537,213 @@ function _hydrate(row) {
   };
 }
 
+// ---- storefront UI chrome catalog --------------------------------------
+//
+// The chrome strings the storefront renders on EVERY page — nav links,
+// search controls, footer columns + links, the newsletter band, the
+// locale switcher. These are the default-locale (`en`) baseline; an
+// operator localises any key by authoring a `translations` row under
+// resource_kind `ui`, resource_id `chrome`, field = the dotted key with
+// dots rewritten to underscores (the table's `field` slug grammar
+// forbids dots), locale = the target tag. `resolveChrome` reads those
+// overrides at boot per active locale and layers them over this baseline,
+// so an untranslated key always renders the English string — never a
+// raw key. The exact English values here are the literal strings the
+// layout shipped inline before i18n landed, so an `en` storefront is
+// byte-identical to the pre-i18n markup.
+//
+// Both render paths (the container `lib/storefront.js` and the edge
+// `worker/render/*`) consume this same catalog through `b.i18n`, so a
+// given locale resolves to one identical string set on both sides.
+var CHROME_KEY_PREFIX = "ui.chrome.";
+var CHROME_RESOURCE_KIND = "ui";
+var CHROME_RESOURCE_ID   = "chrome";
+
+var CHROME_DEFAULTS = Object.freeze({
+  skip_to_content:    "Skip to content",
+
+  util_pill:          "Open source · Apache 2.0",
+  util_msg:           "Server-rendered HTML · post-quantum crypto on by default · zero npm runtime deps",
+  util_star:          "Star on GitHub →",
+
+  search_label:       "Search products",
+  search_placeholder: "Search the catalog",
+  search_submit:      "Search",
+
+  nav_shop:           "Shop",
+  nav_framework:      "Framework",
+  nav_account:        "Account",
+  // The cart aria-label carries the live item count; `{count}` is
+  // interpolated by b.i18n at render time.
+  nav_cart_aria:      "Cart, {count} items",
+
+  newsletter_eyebrow: "Stay in the loop",
+  newsletter_title:   "Get release notes the day they ship.",
+  newsletter_lede:    "No marketing emails. A single short note when there's a new framework release, a security advisory, or a primitive worth knowing about.",
+  newsletter_email:   "Email address",
+  newsletter_submit:  "Subscribe",
+
+  footer_tagline:     "An open-source shop framework — server-rendered HTML, zero npm runtime dependencies, security defaults on.",
+
+  footer_shop_heading:    "Shop",
+  footer_shop_all:        "All products",
+  footer_shop_collections: "Collections",
+  footer_shop_categories: "Categories",
+  footer_shop_new:        "New arrivals",
+  footer_shop_sale:       "On sale",
+  footer_shop_compare:    "Compare",
+  footer_shop_cart:       "Cart",
+
+  footer_framework_heading: "Framework",
+  footer_framework_source:  "Source on GitHub",
+  footer_framework_core:    "blamejs core",
+  footer_framework_security: "Security policy",
+  footer_framework_changelog: "Changelog",
+
+  footer_operators_heading: "Operators",
+  footer_operators_account: "Account",
+  footer_operators_orders:  "Orders",
+  footer_operators_admin:   "Admin",
+  footer_operators_contact: "Contact",
+
+  footer_copy_suffix:  "built on blamejs · Apache 2.0 licensed.",
+  footer_legal_security: "Security",
+  footer_legal_privacy:  "Privacy",
+  footer_legal_terms:    "Terms",
+  footer_legal_cookies:  "Manage cookies",
+
+  locale_switcher_label: "Language",
+  locale_switcher_submit: "Go",
+});
+
+// Default English chrome strings exposed verbatim for the render paths
+// to fall back on when no i18n instance is configured (the storefront
+// stays browsable on a deploy that hasn't seeded a locale policy).
+function chromeDefaults() {
+  return Object.assign({}, CHROME_DEFAULTS);
+}
+
+// Build a `b.i18n` instance carrying the chrome catalog for every active
+// locale. The baseline `en` tree is the shipped defaults; each other
+// locale's tree starts empty and is layered with the operator's `ui`
+// translation rows (read once here). b.i18n's own lookup chain then
+// falls a missing key through to `defaultLocale` (the shipped English),
+// so a partially-translated locale never surfaces a raw key.
+//
+// `opts.overrides` is the pre-read DB override map
+// ({ "<locale>": { "<field>": "<value>", ... } }) — passed in by the
+// caller (the storefront mount reads it via `readChromeOverrides`)
+// rather than read here, so this stays a synchronous, query-free build
+// that the edge Worker can run with the same inputs as the container.
+function createChromeI18n(opts) {
+  opts = opts || {};
+  var defaultLocale = opts.defaultLocale || BASELINE_LOCALE;
+  var locales = Array.isArray(opts.locales) && opts.locales.length
+    ? opts.locales.slice()
+    : [defaultLocale];
+  if (locales.indexOf(defaultLocale) === -1) locales.unshift(defaultLocale);
+  var overrides = opts.overrides || {};
+
+  // Each locale's inline tree under the single `ui.chrome.*` namespace.
+  // The default locale gets the full English baseline; other locales get
+  // only their authored overrides (the rest falls through b.i18n's chain
+  // to the default locale).
+  var translations = {};
+  for (var li = 0; li < locales.length; li += 1) {
+    var loc = locales[li];
+    var chrome = {};
+    if (loc === defaultLocale) {
+      var defKeys = Object.keys(CHROME_DEFAULTS);
+      for (var d = 0; d < defKeys.length; d += 1) chrome[defKeys[d]] = CHROME_DEFAULTS[defKeys[d]];
+    }
+    var ovr = overrides[loc];
+    if (ovr) {
+      var ovrKeys = Object.keys(ovr);
+      for (var o = 0; o < ovrKeys.length; o += 1) {
+        // Only keys we know about land in the tree — an operator typo
+        // (a field that isn't a chrome key) is ignored rather than
+        // shadowing a real string with garbage.
+        if (Object.prototype.hasOwnProperty.call(CHROME_DEFAULTS, ovrKeys[o])) {
+          chrome[ovrKeys[o]] = ovr[ovrKeys[o]];
+        }
+      }
+    }
+    translations[loc] = { ui: { chrome: chrome } };
+  }
+
+  return b.i18n.create({
+    defaultLocale:  defaultLocale,
+    locales:        locales,
+    fallbackLocale: defaultLocale,
+    translations:   translations,
+    // A missing chrome key returns the English baseline via the chain;
+    // should a key be absent from every locale (only possible if the
+    // baseline catalog itself is edited), return the dotted key rather
+    // than throwing inside a render. The render path never shows it
+    // because every shipped key has an `en` baseline.
+    missingKey:     "return-key",
+  });
+}
+
+// Resolve the full chrome string set for one locale into a flat object
+// keyed by the chrome field names (`nav_shop`, `footer_shop_all`, …),
+// each value already locale-resolved through the i18n chain. The render
+// paths feed this straight into the layout placeholders. The
+// `nav_cart_aria` string keeps its literal `{count}` placeholder — the
+// render path interpolates the live cart count uniformly across both
+// substrates, so this stays request-independent and cacheable.
+function resolveChrome(i18n, locale) {
+  var out = {};
+  var keys = Object.keys(CHROME_DEFAULTS);
+  for (var i = 0; i < keys.length; i += 1) {
+    var key = keys[i];
+    // No interpolation vars — `{count}` (and any future placeholder)
+    // survives as a literal for the render path to fill.
+    out[key] = i18n.t(CHROME_KEY_PREFIX + key, {}, { locale: locale });
+  }
+  return out;
+}
+
+// Read the operator's `ui`/`chrome` override rows for the given locales
+// into the `{ "<locale>": { "<field>": "<value>" } }` shape
+// `createChromeI18n` consumes. Missing-table-resilient: a deploy whose
+// `translations` table hasn't been migrated (or a transient read error)
+// yields an empty override map, so the storefront falls back to the
+// English baseline rather than 500-ing. The caller passes a `query`
+// function (the externalDb handle).
+async function readChromeOverrides(query, locales) {
+  if (typeof query !== "function" || !Array.isArray(locales) || !locales.length) return {};
+  var out = {};
+  try {
+    var placeholders = locales.map(function (_l, i) { return "?" + (i + 3); }).join(", ");
+    var rows = (await query(
+      "SELECT locale, field, value FROM translations " +
+      "WHERE resource_kind = ?1 AND resource_id = ?2 AND locale IN (" + placeholders + ")",
+      [CHROME_RESOURCE_KIND, CHROME_RESOURCE_ID].concat(locales)
+    )).rows;
+    for (var i = 0; i < rows.length; i += 1) {
+      var r = rows[i];
+      if (!out[r.locale]) out[r.locale] = {};
+      out[r.locale][r.field] = r.value;
+    }
+  } catch (_e) {
+    // Missing table / read failure — degrade to the English baseline.
+    return {};
+  }
+  return out;
+}
+
 module.exports = {
   create:                  create,
   MAX_VALUE_LEN:           MAX_VALUE_LEN,
   MAX_BULK_ROWS:           MAX_BULK_ROWS,
   BASELINE_LOCALE:         BASELINE_LOCALE,
   DEFAULT_SAMPLE_SIZE:     DEFAULT_SAMPLE_SIZE,
+  CHROME_DEFAULTS:         CHROME_DEFAULTS,
+  CHROME_RESOURCE_KIND:    CHROME_RESOURCE_KIND,
+  CHROME_RESOURCE_ID:      CHROME_RESOURCE_ID,
+  chromeDefaults:          chromeDefaults,
+  createChromeI18n:        createChromeI18n,
+  resolveChrome:           resolveChrome,
+  readChromeOverrides:     readChromeOverrides,
 };

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.5",
-      "tag": "v0.13.5",
+      "version": "0.13.8",
+      "tag": "v0.13.8",
       "license": "Apache-2.0",
       "author": "blamejs contributors",
       "source": "https://github.com/blamejs/blamejs",

package/lib/vendor/blamejs/CHANGELOG.md

@@ -8,6 +8,12 @@ upgrading across more than a few patches at a time.
 
 ## v0.13.x
 
+- v0.13.8 (2026-05-26) — **In-memory archive extraction for read-only / serverless filesystems.** Archive readers gain an in-memory extraction path so an uploaded archive can be opened and its contents read without writing anything to disk — the case a read-only or ephemeral serverless filesystem requires. b.archive.read.zip(...).extractEntries() and b.archive.read.tar(...).extractEntries() are async generators that yield each regular file entry as { name, bytes, size }, applying the same bomb-policy caps, b.guardArchive metadata cascade (which refuses a Zip-Slip / traversal archive wholesale), and entry-type-policy refusals as the disk extract() — only the disk realpath agreement check is omitted, since nothing is written and the caller owns where the returned bytes land. Directory and link entries carry no content and are not yielded. The guard cascade is factored into one shared path so disk and in-memory extraction refuse identically. Also a documentation fix: b.archive.gz no longer claims a b.archive.zip().toGzip() convenience exists — a ZIP is already DEFLATE-compressed per entry, so gzip-wrapping it gains nothing; gzip the uncompressed tar stream (the canonical .tar.gz) instead. **Added:** *`extractEntries()` — in-memory archive extraction (ZIP + tar)* — `b.archive.read.zip(source).extractEntries(opts?)` and `b.archive.read.tar(source).extractEntries(opts?)` are async generators yielding `{ name, bytes, size }` per regular file entry, never touching disk — for serverless / read-only filesystems where the disk `extract({ destination })` path cannot run. Same bomb-policy, guard-archive cascade, and entry-type-policy refusals as disk extraction; the bytes are byte-identical to what `extract()` writes. **Fixed:** *Removed the inaccurate `b.archive.zip().toGzip()` doc claim* — The `b.archive.gz` documentation described a `b.archive.zip().toGzip()` convenience method that does not (and should not) exist: a ZIP is already DEFLATE-compressed per entry, so gzip-wrapping it would compress already-compressed data for no benefit. `b.archive.tar().toGzip()` (the real `.tar.gz`) is unchanged.
+
+- v0.13.7 (2026-05-26) — **Documentation accuracy — several primitives described shipped features as deferred.** A documentation sweep corrected primitive descriptions that still called features deferred after they shipped, so the wiki and inline docs now match the code. b.mdoc documents that device authentication (the ISO 18013-5 §9.1.3 signature variant, verifyDeviceAuth) is verified, not deferred — only the COSE_Mac0 device-auth variant remains refused. b.network.dns.dnssec documents that the root-to-zone chain walk against the IANA trust anchors (verifyChain) and NSEC / NSEC3 denial of existence (verifyDenial / nsec3Hash) ship, where the card previously said they were deferred. b.cose lists COSE_Mac0 and COSE_Encrypt0 among what it ships. The JMAP server documents its push channel, blob upload/download, and EmailSubmission handlers as present, and the submission server documents CHUNKING / BDAT as supported. A new test detector keeps this class of drift from recurring: it fails the build when a comment promises a feature lands in a version that has already shipped. **Fixed:** *Corrected `deferred`/`does-not-ship` docs for features that have shipped* — `b.mdoc` (device authentication, §9.1.3), `b.network.dns.dnssec` (chain walk + NSEC/NSEC3), `b.cose` (COSE_Mac0 + COSE_Encrypt0), the JMAP server (push, blob, EmailSubmission), and the submission server (BDAT/CHUNKING) all carried `@card`/`@intro` text describing shipped capabilities as deferred or not-shipped. The descriptions now match the implemented surface; genuinely-deferred items (the mdoc MAC variant, DNSSEC in-RDATA name canonicalization, COSE multi-signer/multi-recipient) remain documented as such. **Detectors:** *Overdue-defer detector in the codebase-pattern gate* — A new check fails the build when a comment promises a feature "lands in" / is "deferred to" / is "not supported in" a version that the package has already reached — catching stale deferral notes (a feature that shipped but whose comment still says otherwise, or a missed deadline) before they reach a release. An allowlist records the deliberate defer-with-condition exceptions.
+
+- v0.13.6 (2026-05-26) — **`b.ai.frontierModelProtocol` — California SB 53 frontier-AI obligations.** b.ai.frontierModelProtocol assesses a developer's obligations under California's Transparency in Frontier Artificial Intelligence Act — SB 53, Cal. Bus. & Prof. Code §22757.10, effective 2026-01-01 — from a model's training compute and the developer's revenue. It reports whether the model crosses the frontier threshold (more than 10^26 training FLOPs), whether the developer is a large frontier developer (prior-year revenue, with affiliates, above $500M), and the resulting obligations: every frontier developer must report critical safety incidents and publish a transparency report, and a large frontier developer must additionally publish an annual safety framework and disclose its catastrophic-risk assessment. Passing a candidate safety framework reports which required elements (risk identification, mitigation, governance, cybersecurity, standards alignment) are missing. b.ai.frontierModelProtocol.incidentReport validates a critical-incident type against the Act's four categories and computes the notification deadline to the California Office of Emergency Services — 15 days from discovery, or 24 hours when there is an imminent risk of death or serious physical injury. The ca-tfaia compliance posture was already in the catalog. **Added:** *`b.ai.frontierModelProtocol` — SB 53 threshold classification, obligations, and incident reporting* — `b.ai.frontierModelProtocol({ trainingFlops, annualRevenueUsd, framework? })` returns `isFrontierModel`, `isLargeFrontierDeveloper`, the `obligations` list, and (when a framework is supplied) its `frameworkGaps`. `b.ai.frontierModelProtocol.incidentReport({ type, discoveredAt, imminentRiskToLife? })` builds a critical-safety-incident report with the California OES recipient and a `dueAt` / `deadlineHours` computed from the 15-day (or 24-hour imminent-risk) statutory window; `type` must be one of the four categories in `INCIDENT_TYPES`. Throws `FrontierProtocolError` on malformed input.
+
 - v0.13.5 (2026-05-26) — **`b.ai.aedtBiasAudit` — NYC Local Law 144 bias audit.** b.ai.aedtBiasAudit computes the bias-audit figures New York City Local Law 144 requires before an Automated Employment Decision Tool may screen candidates (NYC Admin. Code §20-870 et seq.; DCWP rules 6 RCNY §5-300). Given the per-category counts an independent auditor collected — selected/total for a pass-fail tool, or scored-above-the-overall-median/total for a continuous-score tool — it returns the selection (or scoring) rate, the impact ratio (each group's rate divided by the most-selected group's rate), and an adverse-impact flag (impact ratio below the EEOC four-fifths threshold of 0.8) for every group, across the sex, race/ethnicity, and intersectional dimensions, plus the most-selected group per dimension and an overall flag. Categories under 2% of the audited data are marked excluded per DCWP discretion. It is a pure calculation that produces exactly the figures the annual published summary must contain — the law mandates the calculation, not any particular remediation. The relevant compliance postures (nyc-ll144, and ca-tfaia for California SB 53) were already in the catalog. **Added:** *`b.ai.aedtBiasAudit` — Local Law 144 selection/scoring rates and four-fifths impact ratios* — `b.ai.aedtBiasAudit({ type, metadata, categories, minCategoryShare? })` where `type` is `"selection"` (group entries `{ selected, total }`) or `"scoring"` (`{ scoredAboveMedian, total }`). Returns per-group rate, impact ratio, and `adverseImpact` flag across the `sex`, `raceEthnicity`, and `intersectional` dimensions, plus the most-selected group per dimension and an `anyAdverseImpact` summary. Categories below `minCategoryShare` (2% default) are excluded from the impact-ratio basis. Throws `AedtBiasAuditError` on malformed input.
 
 - v0.13.4 (2026-05-26) — **`b.crdt` — conflict-free replicated data types.** b.crdt adds state-based Conflict-free Replicated Data Types: data structures that independent replicas update without coordination and still converge to the same value once they have exchanged state. Each type's merge is a join over a semilattice — commutative, associative, and idempotent — so replicas can merge in any order, any number of times, and agree, which makes these the substrate for active/active cluster state, offline-first clients that reconcile on reconnect, and eventually-consistent counters, sets, and maps. The release ships the full state-based family: grow-only and positive-negative counters (gCounter / pnCounter), grow-only, two-phase, and observed-remove sets (gSet / twoPSet / orSet), a last-write-wins register (lwwRegister), and an observed-remove map (orMap). Every type exposes the same contract — local mutators, merge(other) that returns a converged instance without mutating either operand, value() for the materialized value, and state() / fromState() for a JSON-serializable form to snapshot via b.archive or b.backup or ship to a peer — and carries a replicaId so per-replica contributions stay distinct. **Added:** *`b.crdt` — state-based CvRDT counters, sets, register, and map* — `b.crdt.gCounter` / `pnCounter` (grow-only and increment/decrement counters), `b.crdt.gSet` / `twoPSet` / `orSet` (grow-only, two-phase, and observed-remove sets — `orSet` supports re-add and resolves a concurrent add-vs-remove as add-wins), `b.crdt.lwwRegister` (last-write-wins with a deterministic replicaId tie-break), and `b.crdt.orMap` (observed-remove keys with last-write-wins values). Each exposes `merge` / `value` / `state` / `fromState` and converges by the CvRDT laws. `orSet` and `orMap` accept `tombstoneRetention` to bound tombstone memory against a remove flood.

package/lib/vendor/blamejs/README.md

@@ -190,6 +190,7 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **AI usage quotas** — per-tenant / per-model budgets metered by tokens / requests / cost-usd / compute-hours over calendar-aligned windows, with an atomic conditional reserve (no charge-then-refund race) + hard/soft/warn enforcement and an optional cross-node store; defends OWASP LLM10:2025 unbounded consumption / denial-of-wallet (`b.ai.quota`)
 - **AI capability routing** — model-capability registry (context window / modalities / tool use / reasoning tier / cost rates) + a router that picks the cheapest model satisfying a request's requirements, refusing capability mismatches before the inference call (NIST AI RMF MAP + Model Cards); composes with `b.ai.quota` cost budgets (`b.ai.capability`)
 - **AEDT bias audit** — NYC Local Law 144 bias-audit figures (`b.ai.aedtBiasAudit`): selection / scoring rates and EEOC four-fifths-rule impact ratios across sex, race/ethnicity, and their intersection, with the most-selected group and adverse-impact flags (impact ratio < 0.8) for the annual published summary; sub-2% categories excludable per DCWP §5-301
+- **Frontier AI protocol** — California SB 53 (Transparency in Frontier AI Act) obligations (`b.ai.frontierModelProtocol`): classify the frontier-model (>10²⁶ training FLOPs) and large-frontier-developer (>$500M revenue) thresholds, enumerate the resulting obligations, check a safety framework for required elements, and build a critical-safety-incident report with the 15-day / 24-hour California OES notification deadline (`.incidentReport`)
 ### Compliance regimes
 
 - **Posture coordinator** — `b.compliance` cascades operator-declared regime into retention / audit / db / cryptoField via POSTURE_DEFAULTS:
@@ -227,7 +228,7 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **i18n** — CLDR plural rules, Accept-Language negotiation, Intl formatters, RTL (`b.i18n`)
 - **CSV** — RFC 4180 with Excel formula-injection prevention (`b.csv`)
 - **IDs + slugs** — RFC 9562 UUID v4 + v7 (`b.uuid`); URL-safe slugs (`b.slug`)
-- **Time + archive** — TZ-aware datetime (`b.time`); ZIP creation + adversarial-safe read with bomb caps + path-traversal + LFH/CD-skew defense (`b.archive` + `b.archive.read.zip`); one-liner quarantine extraction (`b.safeArchive.extract`); fs / objectStore / http / buffer / trusted-stream adapter contract (`b.archive.adapters`)
+- **Time + archive** — TZ-aware datetime (`b.time`); ZIP creation + adversarial-safe read with bomb caps + path-traversal + LFH/CD-skew defense (`b.archive` + `b.archive.read.zip`); one-liner quarantine extraction (`b.safeArchive.extract`); in-memory extraction with no disk write for read-only / serverless filesystems (`b.archive.read.zip(...).extractEntries()` / `.tar`); fs / objectStore / http / buffer / trusted-stream adapter contract (`b.archive.adapters`)
 - **Pagination + forms** — HMAC-signed cursor pagination (`b.pagination`); HTML form rendering + validation + CSRF (`b.forms`)
 
 ### Production

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

@@ -1,7 +1,7 @@
 {
   "version": 1,
-  "frameworkVersion": "0.13.5",
-  "createdAt": "2026-05-27T01:38:32.776Z",
+  "frameworkVersion": "0.13.8",
+  "createdAt": "2026-05-27T05:03:11.726Z",
   "exports": {
     "a2a": {
       "type": "object",
@@ -1577,6 +1577,10 @@
             }
           }
         },
+        "frontierModelProtocol": {
+          "type": "function",
+          "arity": 1
+        },
         "input": {
           "type": "object",
           "members": {

package/lib/vendor/blamejs/index.js

@@ -478,6 +478,7 @@ module.exports = {
     capability:      require("./lib/ai-capability"),
     dp:              require("./lib/ai-dp"),
     aedtBiasAudit:   require("./lib/ai-aedt-bias-audit"),
+    frontierModelProtocol: require("./lib/ai-frontier-protocol"),
   },
   promisePool:      require("./lib/promise-pool"),
   sdNotify:         require("./lib/sd-notify"),

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

@@ -187,9 +187,8 @@ function chatbot(session, opts) {
  * machine-readable manner. This primitive returns the disclosure
  * payload (visible label + structured metadata) the operator wires
  * into the encoder / response pipeline. C2PA manifest emission is
- * deferred to v0.12.21 `b.contentCredentials` — this primitive
- * supplies the label markup and the metadata schema that the C2PA
- * adapter consumes when it lands.
+ * handled by `b.contentCredentials`; this primitive supplies the label
+ * markup and the metadata schema that the C2PA adapter consumes.
  *
  * @opts
  *   contentType:   "image" | "audio" | "video" | "text",        // required

package/lib/vendor/blamejs/lib/ai-frontier-protocol.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * @module b.ai.frontierModelProtocol
+ * @nav    Compliance
+ * @title  Frontier AI Protocol
+ *
+ * @intro
+ *   Assess a developer's obligations under California's Transparency in
+ *   Frontier Artificial Intelligence Act — SB 53, Cal. Bus. & Prof. Code
+ *   §22757.10 et seq., signed 2025-09-29 and effective 2026-01-01 — and build
+ *   the critical-safety-incident report the law requires. SB 53 attaches
+ *   obligations by two thresholds: a <em>frontier model</em> is one trained
+ *   with more than 10<sup>26</sup> floating-point operations (including
+ *   cumulative fine-tuning), and a <em>large frontier developer</em> is a
+ *   frontier developer whose annual revenue, with affiliates, exceeded
+ *   $500,000,000 in the prior calendar year. Frontier developers must report
+ *   critical safety incidents; large frontier developers must additionally
+ *   publish an annual frontier-AI safety framework.
+ *
+ *   <code>frontierModelProtocol(opts)</code> takes the model's training compute
+ *   and the developer's revenue and returns which thresholds are crossed and
+ *   the resulting obligations, optionally checking that a supplied safety
+ *   framework carries the elements the Act expects (risk identification,
+ *   mitigation, governance, cybersecurity, and alignment with a recognized
+ *   standard such as the NIST AI RMF or ISO/IEC 42001).
+ *   <code>frontierModelProtocol.incidentReport(opts)</code> validates a
+ *   critical-incident type against the Act's four definitions and computes the
+ *   notification deadline: a routine report goes to the California Office of
+ *   Emergency Services within 15 days of discovery; an imminent risk of death
+ *   or serious physical injury is reported to an applicable authority within 24
+ *   hours.
+ *
+ * @card
+ *   California SB 53 frontier-AI protocol (`b.ai.frontierModelProtocol`) —
+ *   classify frontier-model / large-developer thresholds (10²⁶ FLOPs, $500M
+ *   revenue), enumerate obligations, and build the critical-safety-incident
+ *   report with the 15-day / 24-hour OES notification deadline.
+ */
+
+var C = require("./constants");
+var { defineClass } = require("./framework-error");
+
+var FrontierProtocolError = defineClass("FrontierProtocolError", { alwaysPermanent: true });
+
+// SB 53 thresholds.
+var FRONTIER_FLOP_THRESHOLD = 1e26;          // > 10^26 training FLOPs → frontier model
+var LARGE_DEVELOPER_REVENUE_USD = 5e8;       // > $500,000,000 prior-year revenue → large developer
+var INCIDENT_DEADLINE_MS = C.TIME.days(15);  // report to CA OES within 15 days of discovery
+var IMMINENT_DEADLINE_MS = C.TIME.hours(24); // within 24 hours if imminent risk to life
+
+// The four critical safety incident categories (Cal. Bus. & Prof. Code §22757.10).
+var CRITICAL_INCIDENT_TYPES = {
+  "weights-exfiltration-harm":         "Unauthorized access, modification, or exfiltration of frontier-model weights resulting in death or bodily injury",
+  "catastrophic-risk-materialization": "Harm resulting from the materialization of a catastrophic risk (including loss of life or property from a dangerous capability)",
+  "loss-of-control-harm":              "Loss of control of a frontier model causing death or bodily injury",
+  "deceptive-control-subversion":      "A frontier model using deceptive techniques to subvert developer controls, demonstrating materially increased catastrophic risk",
+};
+
+// Elements a large frontier developer's published safety framework must address.
+var REQUIRED_FRAMEWORK_ELEMENTS = ["riskIdentification", "riskMitigation", "governance", "cybersecurity", "standardsAlignment"];
+
+function _posNum(v, label) {
+  if (typeof v !== "number" || !isFinite(v) || v < 0) throw new FrontierProtocolError("frontier/bad-value", "frontierModelProtocol: " + label + " must be a non-negative finite number");
+  return v;
+}
+
+/**
+ * @primitive  b.ai.frontierModelProtocol
+ * @signature  b.ai.frontierModelProtocol(opts)
+ * @since      0.13.6
+ * @status     stable
+ * @compliance ca-tfaia, soc2
+ * @related    b.ai.aedtBiasAudit, b.ai.disclosure.applyAll
+ *
+ * Determine SB 53 obligations from a model's training compute and the
+ * developer's revenue. Returns <code>isFrontierModel</code> (training FLOPs
+ * above 10<sup>26</sup>), <code>isLargeFrontierDeveloper</code> (a frontier
+ * developer with revenue above $500M), and the resulting
+ * <code>obligations</code>. When <code>framework</code> is supplied, its
+ * required elements are checked and reported in <code>frameworkGaps</code>.
+ * Throws <code>FrontierProtocolError</code> on malformed input.
+ *
+ * @opts
+ *   trainingFlops:    number,   // total training FLOPs incl. fine-tuning (required)
+ *   annualRevenueUsd: number,   // developer prior-year revenue with affiliates (default: 0)
+ *   framework:        object,   // optional safety framework to check for required elements
+ *
+ * @example
+ *   var p = b.ai.frontierModelProtocol({ trainingFlops: 5e26, annualRevenueUsd: 1e9 });
+ *   p.isFrontierModel;           // → true
+ *   p.isLargeFrontierDeveloper;  // → true
+ *   p.obligations;               // → ["report-critical-safety-incidents", "publish-annual-safety-framework", ...]
+ */
+function frontierModelProtocol(opts) {
+  opts = opts || {};
+  if (typeof opts !== "object") throw new FrontierProtocolError("frontier/bad-opts", "frontierModelProtocol: opts must be an object");
+  var allowed = { trainingFlops: 1, annualRevenueUsd: 1, framework: 1 };
+  Object.keys(opts).forEach(function (k) { if (!allowed[k]) throw new FrontierProtocolError("frontier/bad-opts", "frontierModelProtocol: unknown option '" + k + "'"); });
+
+  var flops = _posNum(opts.trainingFlops, "trainingFlops");
+  var revenue = opts.annualRevenueUsd != null ? _posNum(opts.annualRevenueUsd, "annualRevenueUsd") : 0;
+
+  var isFrontierModel = flops > FRONTIER_FLOP_THRESHOLD;
+  var isLargeFrontierDeveloper = isFrontierModel && revenue > LARGE_DEVELOPER_REVENUE_USD;
+
+  var obligations = [];
+  if (isFrontierModel) {
+    obligations.push("report-critical-safety-incidents");
+    obligations.push("publish-transparency-report");
+  }
+  if (isLargeFrontierDeveloper) {
+    obligations.push("publish-annual-safety-framework");
+    obligations.push("disclose-catastrophic-risk-assessment");
+  }
+
+  var out = {
+    isFrontierModel: isFrontierModel,
+    isLargeFrontierDeveloper: isLargeFrontierDeveloper,
+    thresholds: { frontierFlops: FRONTIER_FLOP_THRESHOLD, largeDeveloperRevenueUsd: LARGE_DEVELOPER_REVENUE_USD },
+    obligations: obligations,
+  };
+
+  if (opts.framework != null) {
+    if (typeof opts.framework !== "object") throw new FrontierProtocolError("frontier/bad-value", "frontierModelProtocol: framework must be an object");
+    var gaps = REQUIRED_FRAMEWORK_ELEMENTS.filter(function (el) { return !opts.framework[el]; });
+    out.frameworkGaps = gaps;
+    out.frameworkComplete = gaps.length === 0;
+  }
+  return out;
+}
+
+/**
+ * @primitive  b.ai.frontierModelProtocol.incidentReport
+ * @signature  b.ai.frontierModelProtocol.incidentReport(opts)
+ * @since      0.13.6
+ * @status     stable
+ * @compliance ca-tfaia, soc2
+ * @related    b.ai.frontierModelProtocol, b.ai.aedtBiasAudit
+ *
+ * Build a critical-safety-incident report and compute its notification
+ * deadline to the California Office of Emergency Services. <code>type</code>
+ * must be one of the Act's four categories; <code>discoveredAt</code> is when
+ * the incident was discovered. The deadline is 15 days from discovery, or 24
+ * hours when <code>imminentRiskToLife</code> is set. Returns the structured
+ * report with <code>dueAt</code> and <code>deadlineHours</code>. Throws
+ * <code>FrontierProtocolError</code> on an unknown type or bad timestamp.
+ *
+ * @opts
+ *   type:               string,   // one of b.ai.frontierModelProtocol.INCIDENT_TYPES (required)
+ *   discoveredAt:       Date,     // discovery time (Date or epoch-ms; default: now)
+ *   imminentRiskToLife: boolean,  // true → 24-hour deadline (default: false → 15 days)
+ *   description:        string,   // free-text incident description (optional)
+ *
+ * @example
+ *   var r = b.ai.frontierModelProtocol.incidentReport({
+ *     type: "loss-of-control-harm", discoveredAt: new Date("2026-06-01T00:00:00Z"),
+ *   });
+ *   r.deadlineHours;   // → 360  (15 days)
+ *   r.recipient;       // → "California Office of Emergency Services"
+ */
+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(", "));
+
+  var discoveredMs;
+  if (opts.discoveredAt == null) discoveredMs = Date.now();
+  else if (opts.discoveredAt instanceof Date) discoveredMs = opts.discoveredAt.getTime();
+  else discoveredMs = Number(opts.discoveredAt);
+  if (!isFinite(discoveredMs) || discoveredMs < 0) throw new FrontierProtocolError("frontier/bad-value", "incidentReport: discoveredAt must be a Date or non-negative epoch-ms");
+
+  var imminent = opts.imminentRiskToLife === true;
+  var windowMs = imminent ? IMMINENT_DEADLINE_MS : INCIDENT_DEADLINE_MS;
+
+  return {
+    type:               opts.type,
+    typeDescription:    CRITICAL_INCIDENT_TYPES[opts.type],
+    description:        typeof opts.description === "string" ? opts.description : null,
+    imminentRiskToLife: imminent,
+    discoveredAt:       new Date(discoveredMs).toISOString(),
+    dueAt:              new Date(discoveredMs + windowMs).toISOString(),
+    deadlineHours:      windowMs / C.TIME.hours(1),
+    // §22757.13: the routine report goes to OES within 15 days; an imminent
+    // risk of death or serious physical injury is reported to an applicable
+    // authority within 24 hours, which the operator selects for the incident.
+    recipient:          imminent ? "An applicable authority with jurisdiction (e.g. law enforcement or a public-safety agency)" : "California Office of Emergency Services",
+    citation:           "Cal. Bus. & Prof. Code §22757.13 (SB 53)",
+  };
+}
+
+frontierModelProtocol.incidentReport = incidentReport;
+frontierModelProtocol.INCIDENT_TYPES = Object.keys(CRITICAL_INCIDENT_TYPES);
+frontierModelProtocol.REQUIRED_FRAMEWORK_ELEMENTS = REQUIRED_FRAMEWORK_ELEMENTS;
+frontierModelProtocol.FrontierProtocolError = FrontierProtocolError;
+
+module.exports = frontierModelProtocol;

package/lib/vendor/blamejs/lib/archive-gz.js

@@ -47,9 +47,11 @@ function _isGzipMagic(buf) {
  * `toAdapter(adapter)` / `digest()` — so gzip slots into the same
  * downstream sinks (object-store + filesystem + http adapters).
  *
- * Composes `b.archive.tar().toGzip(adapter)` / `b.archive.zip().
- * toGzip(adapter)` indirectly: those convenience methods call this
- * primitive after materializing their archive bytes.
+ * `b.archive.tar().toGzip(adapter)` composes this primitive after
+ * materializing the tar bytes (the canonical `.tar.gz`). There is no
+ * `zip().toGzip()` — a ZIP is already DEFLATE-compressed per entry, so
+ * gzip-wrapping it would compress already-compressed data for no gain;
+ * gzip the uncompressed tar stream instead.
  *
  * @opts
  *   level:  number,    // 0-9, default 6 (zlib default).