@blamejs/core 0.13.4 → 0.13.6

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.13.x
 
+- 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.
 
 - v0.13.3 (2026-05-26) — **`b.crypto.xwing` — X-Wing hybrid post-quantum KEM.** b.crypto.xwing adds the X-Wing hybrid key-encapsulation mechanism (draft-connolly-cfrg-xwing-kem): it runs ML-KEM-768 and X25519 side by side and binds their shared secrets with SHA3-256, so an encapsulated key stays secure as long as either ML-KEM-768 or X25519 holds. That is the conservative shape for moving off classical ECDH today — a harvest-now-decrypt-later attacker must break the lattice KEM, and a hypothetical ML-KEM break still leaves X25519 standing. keygen() produces a 32-byte decapsulation seed and a 1216-byte public key; encapsulate(publicKey) returns a 1120-byte ciphertext and a 32-byte shared secret; decapsulate(secretKey, ciphertext) recovers it. The X-Wing combiner is frozen, but its specification is still an IETF Internet-Draft, so this primitive is marked experimental and sits beside the existing pre-RFC post-quantum HPKE drafts; it composes the framework's vendored ML-KEM-768 and X25519 with SHA3 and adds no new cryptographic core. The combiner is known-answer-tested byte-for-byte against the draft's definition. **Added:** *`b.crypto.xwing` — X-Wing hybrid PQ/T KEM (experimental)* — `keygen(seed?)` → `{ publicKey (1216 B), secretKey (32-byte seed) }`; `encapsulate(publicKey, eseed?)` → `{ ciphertext (1120 B), sharedSecret (32 B) }`; `decapsulate(secretKey, ciphertext)` → the 32-byte shared secret. Both `keygen` and `encapsulate` accept an optional seed for deterministic operation. The combiner — `SHA3-256(ssMLKEM ‖ ssX25519 ‖ ctX25519 ‖ pkX25519 ‖ label)` — is exposed as `combiner` for advanced use. Marked `experimental` while draft-connolly-cfrg-xwing-kem remains an Internet-Draft; the algorithm itself is frozen.

package/README.md

@@ -189,6 +189,8 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **Content provenance** — C2PA 2.1 + California SB-942 / AB-853 manifest builder for AI-generated media (provider, model id + version, timestamp, content ID, signed) (`b.contentCredentials`)
 - **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:

package/index.js

@@ -477,6 +477,8 @@ module.exports = {
     quota:           require("./lib/ai-quota"),
     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/ai-aedt-bias-audit.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * @module b.ai.aedtBiasAudit
+ * @nav    Compliance
+ * @title  AEDT Bias Audit
+ *
+ * @intro
+ *   Compute the bias-audit statistics New York City Local Law 144 requires
+ *   before an Automated Employment Decision Tool (AEDT) may be used to screen
+ *   candidates or employees. The law (NYC Admin. Code §20-870 et seq., in force
+ *   since 2023-07-05; DCWP rules 6 RCNY §5-300 et seq.) requires an independent
+ *   annual audit that reports, for each demographic category, the rate at which
+ *   the tool selects (or scores above the median for) that group and the
+ *   <em>impact ratio</em> — that group's rate divided by the rate of the
+ *   most-selected group. An impact ratio below the four-fifths (0.8) threshold
+ *   from the EEOC Uniform Guidelines flags potential adverse impact; the law
+ *   requires the number to be calculated and published, not any particular
+ *   remediation.
+ *
+ *   The audit is computed across three dimensions: sex, race/ethnicity, and
+ *   the intersection of the two, using the EEOC categories. Categories that
+ *   make up less than 2% of the audited data may be excluded from the impact-
+ *   ratio calculation at the auditor's discretion (DCWP §5-301). This primitive
+ *   takes the per-category counts — selected/total for a pass-fail tool, or
+ *   scored-above-the-overall-median/total for a continuous-score tool — and
+ *   returns the selection (or scoring) rate, impact ratio, and adverse-impact
+ *   flag per group, plus the most-selected group and an overall flag. It is a
+ *   pure calculation: the operator supplies the data an independent auditor
+ *   collected, and gets back the figures the published summary must contain.
+ *
+ * @card
+ *   NYC Local Law 144 AEDT bias audit (`b.ai.aedtBiasAudit`) — selection /
+ *   scoring rates and four-fifths-rule impact ratios across sex, race/ethnicity,
+ *   and their intersection, with the most-selected group and adverse-impact
+ *   flags for the published audit summary.
+ */
+
+var validateOpts = require("./validate-opts");
+var { defineClass } = require("./framework-error");
+
+var AedtBiasAuditError = defineClass("AedtBiasAuditError", { alwaysPermanent: true });
+
+var FOUR_FIFTHS = 4 / 5;         // EEOC Uniform Guidelines four-fifths adverse-impact threshold
+var DEFAULT_MIN_SHARE = 0.02;    // DCWP §5-301 — categories under 2% may be excluded
+var DIMENSIONS = ["sex", "raceEthnicity", "intersectional"];
+
+function _str(v, label) {
+  if (typeof v !== "string" || v.length === 0) throw new AedtBiasAuditError("aedt/bad-metadata", "aedtBiasAudit: metadata." + label + " must be a non-empty string");
+  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");
+  return v;
+}
+
+// Reduce one dimension's per-group counts to the LL-144 figures.
+function _auditDimension(groups, type, minShare) {
+  var names = Object.keys(groups);
+  var rows = [];
+  var dimensionTotal = 0;
+  var numeratorKey = type === "scoring" ? "scoredAboveMedian" : "selected";
+
+  names.forEach(function (name) {
+    var g = groups[name];
+    if (!g || typeof g !== "object") throw new AedtBiasAuditError("aedt/bad-count", "aedtBiasAudit: group '" + name + "' must be an object with " + numeratorKey + " + total");
+    var total = _count(g.total, name + ".total");
+    var num = _count(g[numeratorKey], name + "." + numeratorKey);
+    if (num > total) throw new AedtBiasAuditError("aedt/bad-count", "aedtBiasAudit: " + name + "." + numeratorKey + " (" + num + ") exceeds total (" + total + ")");
+    dimensionTotal += total;
+    rows.push({ category: name, total: total, _num: num, rate: total === 0 ? 0 : num / total });
+  });
+
+  // Exclude sub-threshold categories (auditor discretion), then find the
+  // most-selected group among those that remain.
+  var maxRate = 0;
+  var mostSelected = null;
+  rows.forEach(function (r) {
+    r.share = dimensionTotal === 0 ? 0 : r.total / dimensionTotal;
+    r.excluded = dimensionTotal > 0 && r.share < minShare;
+    if (!r.excluded && r.rate > maxRate) { maxRate = r.rate; mostSelected = r.category; }
+  });
+
+  rows.forEach(function (r) {
+    r.impactRatio = (r.excluded || maxRate === 0) ? null : r.rate / maxRate;
+    r.adverseImpact = r.impactRatio !== null && r.impactRatio < FOUR_FIFTHS;
+    delete r._num;
+  });
+  // Stable order: highest rate first, then category name.
+  rows.sort(function (a, b) { return b.rate - a.rate || (a.category < b.category ? -1 : a.category > b.category ? 1 : 0); });
+  return { rows: rows, mostSelected: mostSelected };
+}
+
+/**
+ * @primitive  b.ai.aedtBiasAudit
+ * @signature  b.ai.aedtBiasAudit(opts)
+ * @since      0.13.5
+ * @status     stable
+ * @compliance nyc-ll144, soc2
+ * @related    b.ai.disclosure.applyAll, b.ai.disclosure.chatbot
+ *
+ * Compute the NYC Local Law 144 bias-audit figures from per-category counts.
+ * <code>type</code> is <code>"selection"</code> for a pass-fail tool (each
+ * group entry is <code>{ selected, total }</code>) or <code>"scoring"</code>
+ * for a continuous-score tool (<code>{ scoredAboveMedian, total }</code>, where
+ * the count is candidates scoring above the <em>overall</em> median). Returns
+ * the selection/scoring rate, impact ratio (group rate ÷ most-selected group's
+ * rate), and an <code>adverseImpact</code> flag (impact ratio &lt; 0.8) per
+ * group, across the <code>sex</code>, <code>raceEthnicity</code>, and
+ * <code>intersectional</code> dimensions, plus the most-selected group per
+ * dimension. Categories under <code>minCategoryShare</code> (2% by default) are
+ * marked <code>excluded</code> and left out of the impact-ratio basis. Throws
+ * <code>AedtBiasAuditError</code> on malformed input. The result is the data an
+ * employer must publish; the law mandates the calculation, not any remediation.
+ *
+ * @opts
+ *   type:             string,   // "selection" | "scoring" (required)
+ *   metadata:         object,   // { tool, auditor, auditDate, distributionDate? } (tool/auditor/auditDate required)
+ *   categories:       object,   // { sex?, raceEthnicity?, intersectional? } → { <group>: { selected|scoredAboveMedian, total } }
+ *   minCategoryShare: number,   // default: 0.02 (DCWP §5-301 — sub-2% categories may be excluded)
+ *
+ * @example
+ *   var report = b.ai.aedtBiasAudit({
+ *     type: "selection",
+ *     metadata: { tool: "ResumeRanker v3", auditor: "Acme Audit LLC", auditDate: "2026-05-26" },
+ *     categories: { sex: { Male: { selected: 60, total: 100 }, Female: { selected: 42, total: 100 } } },
+ *   });
+ *   report.results.sex[1].impactRatio;   // → 0.7  (Female: 42% / 60%)
+ *   report.results.sex[1].adverseImpact; // → true (below the 0.8 four-fifths threshold)
+ */
+function aedtBiasAudit(opts) {
+  opts = opts || {};
+  // Surface an unknown/typoed option as this primitive's own error type rather
+  // than the generic Error validateOpts throws, so the malformed-input contract
+  // (AedtBiasAuditError / e.code) holds for every bad-config path.
+  try { validateOpts(opts, ["type", "metadata", "categories", "minCategoryShare"], "aedtBiasAudit"); }
+  catch (e) { throw new AedtBiasAuditError("aedt/bad-opts", e && e.message || "aedtBiasAudit: invalid options"); }
+  if (opts.type !== "selection" && opts.type !== "scoring") throw new AedtBiasAuditError("aedt/bad-type", "aedtBiasAudit: type must be 'selection' or 'scoring'");
+
+  var md = opts.metadata || {};
+  var metadata = {
+    tool:             _str(md.tool, "tool"),
+    auditor:          _str(md.auditor, "auditor"),
+    auditDate:        _str(md.auditDate, "auditDate"),
+    distributionDate: md.distributionDate != null ? _str(md.distributionDate, "distributionDate") : null,
+  };
+
+  var minShare = opts.minCategoryShare != null ? opts.minCategoryShare : DEFAULT_MIN_SHARE;
+  if (typeof minShare !== "number" || !isFinite(minShare) || minShare < 0 || minShare >= 1) throw new AedtBiasAuditError("aedt/bad-share", "aedtBiasAudit: minCategoryShare must be a number in [0, 1)");
+
+  var cats = opts.categories || {};
+  var present = DIMENSIONS.filter(function (d) { return cats[d] && typeof cats[d] === "object" && Object.keys(cats[d]).length > 0; });
+  if (present.length === 0) throw new AedtBiasAuditError("aedt/no-categories", "aedtBiasAudit: at least one of sex / raceEthnicity / intersectional must carry group counts");
+
+  var results = {};
+  var mostSelected = {};
+  var adverseImpactGroups = [];
+  present.forEach(function (dim) {
+    var out = _auditDimension(cats[dim], opts.type, minShare);
+    results[dim] = out.rows;
+    mostSelected[dim] = out.mostSelected;
+    out.rows.forEach(function (r) { if (r.adverseImpact) adverseImpactGroups.push({ dimension: dim, category: r.category, impactRatio: r.impactRatio }); });
+  });
+
+  return {
+    type:     opts.type,
+    metadata: metadata,
+    results:  results,
+    summary:  {
+      mostSelected:        mostSelected,
+      adverseImpactGroups: adverseImpactGroups,
+      anyAdverseImpact:    adverseImpactGroups.length > 0,
+      fourFifthsThreshold: FOUR_FIFTHS,
+    },
+  };
+}
+
+aedtBiasAudit.FOUR_FIFTHS = FOUR_FIFTHS;
+aedtBiasAudit.AedtBiasAuditError = AedtBiasAuditError;
+
+module.exports = aedtBiasAudit;

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:832111fb-8b91-4fb8-bb5f-c491bae476c5",
+  "serialNumber": "urn:uuid:4234e2f1-7c10-42c0-8f19-b429101d42d1",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-27T01:19:38.243Z",
+    "timestamp": "2026-05-27T03:23:03.075Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.13.4",
+      "bom-ref": "@blamejs/core@0.13.6",
       "type": "application",
       "name": "blamejs",
-      "version": "0.13.4",
+      "version": "0.13.6",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.13.4",
+      "purl": "pkg:npm/%40blamejs/core@0.13.6",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.13.4",
+      "ref": "@blamejs/core@0.13.6",
       "dependsOn": []
     }
   ]