@labpics/colors 0.6.2 → 0.7.0

package/adapt-theme.js

@@ -48,7 +48,15 @@
 //     with no legal floor (decorative) ease freely either way.
 
 import { applyTheme } from "./apply-theme.js";
-import { effectiveBackground, parseCssColor, oklabLerp } from "./effective-bg.js";
+import {
+  effectiveBackground,
+  parseCssColor,
+  oklabLerp,
+  compileLerpPair,
+  lerpPairHex,
+  lerpPairLuminance,
+  wcagLuminanceCached,
+} from "./effective-bg.js";
 
 /** Cubic ease-out: fast start, gentle settle, no overshoot. A non-finite `t`
  * (e.g. a NaN clock making `(now - easeStart) / easeMs` NaN) is treated as a
@@ -78,10 +86,23 @@ function wcagRatio(lumA, lumB) {
   return (hi + 0.05) / (lo + 0.05);
 }
 
-/** Interpolate two `#RRGGBB` hexes at `t ∈ [0,1]` in Oklab, so the crossfade is
- * perceptually even (no lingering-bright sRGB midpoint, no muddy chroma path). */
-function lerpHex(from, to, t) {
-  return oklabLerp(from, to, t);
+/** Interpolate an ease segment at `t ∈ [0,1]` in Oklab, so the crossfade is
+ * perceptually even (no lingering-bright sRGB midpoint, no muddy chroma path).
+ * Segments carry a compiled pair (`compileLerpPair`) when both endpoints
+ * parse — the always-case in practice, both being engine-emitted `#RRGGBB` —
+ * so per-frame interpolation runs on pre-parsed Oklab coordinates instead of
+ * re-parsing both endpoint strings every frame. A `null` pair falls back to
+ * `oklabLerp`, which owns the unparseable-endpoint fallback semantics.
+ * Byte-identical either way (locked by test/hotpath-parity.test.mjs). */
+function segHex(seg, t) {
+  return seg.pair ? lerpPairHex(seg.pair, t) : oklabLerp(seg.from, seg.to, t);
+}
+
+/** WCAG relative luminance of `segHex(seg, t)` — numeric fast path on the
+ * compiled pair (no `#RRGGBB` round-trip), string path otherwise. Strict
+ * mode's `floorBlend` bisection calls this up to 14× per role per frame. */
+function segLum(seg, t) {
+  return seg.pair ? lerpPairLuminance(seg.pair, t) : relativeLuminanceHex(segHex(seg, t));
 }
 
 /**
@@ -156,7 +177,7 @@ export function adaptTheme(element, options) {
    * roles are never dropped by `applyTheme`'s clear-then-write and always carry
    * the current theme's value. Only `kind === "color"` roles (in `roles`) ease. */
   let baseVars = {};
-  /** @type {Map<string,{from:string,to:string}>} in-flight ease per cssVar */
+  /** @type {Map<string,{from:string,to:string,held:number,pair:object|null}>} in-flight ease per cssVar */
   let easing = new Map();
   let easeStart = 0;
   let breachSince = null;
@@ -190,12 +211,16 @@ export function adaptTheme(element, options) {
   // dropFraction)`) against ANY sample. `worstIdx` is the sample with the least
   // set-wide margin — the one to re-solve against, so the constraint we solve to
   // is the same constraint we check hardest.
-  const recheckSamples = (fgs, samples) => {
+  // The current foreground hexes, refreshed on adopt. Rechecks run per changed
+  // frame and previously rebuilt this identical array from `roles` each time.
+  let fgsCache = [];
+
+  const recheckSamples = (samples) => {
     let breached = false;
     let worstIdx = 0;
     let worstMargin = Infinity;
     for (let s = 0; s < samples.length; s++) {
-      const flat = colors.recheckContrast(samples[s], fgs, theme);
+      const flat = colors.recheckContrast(samples[s], fgsCache, theme);
       let sampleMargin = Infinity;
       for (let i = 0; i < roles.length; i++) {
         const want = Math.abs(roles[i].lc) * (1 - dropFraction);
@@ -227,6 +252,10 @@ export function adaptTheme(element, options) {
         hex: r.hex,
         legalFloor: typeof r.legalFloor === "number" ? r.legalFloor : null,
       }));
+    fgsCache = roles.map((r) => r.hex);
+    // The adopt may change the var/role KEY SET — force the next write through
+    // `applyTheme`'s full clear-then-write instead of the mid-ease diff path.
+    written = null;
     lastSolveAt = now;
     breachSince = null;
     return result;
@@ -242,19 +271,41 @@ export function adaptTheme(element, options) {
   const solveAndAdoptWorst = (samples, now) => {
     solveAndAdopt(samples[0], now);
     if (samples.length > 1) {
-      const { worstIdx } = recheckSamples(
-        roles.map((r) => r.hex),
-        samples,
-      );
+      const { worstIdx } = recheckSamples(samples);
       if (worstIdx !== 0) solveAndAdopt(samples[worstIdx], now);
     }
   };
 
   // Every write goes through the full canonical set with the (optional) eased
   // color overlay on top — so translucent roles in `baseVars` persist through
-  // `applyTheme`'s clear-then-write, and non-eased color roles keep their
-  // canonical oklch form. `overlay` carries only in-flight color roles as hex.
-  const applyHexes = (overlay) => applyTheme(target, { vars: { ...baseVars, ...overlay } });
+  // the apply, and non-eased color roles keep their canonical oklch form.
+  // `overlay` carries only in-flight color roles as hex.
+  //
+  // WRITE STRATEGY — full vs diff. `written` holds the vars of the last write;
+  // `null` forces the next write through `applyTheme`'s full clear-then-write.
+  // Between two adopts the composed key set is invariant (always `baseVars`'
+  // keys), so mid-ease frames DIFF against `written`: only values that changed
+  // this frame hit `setProperty` (≈ the roles actually easing), instead of
+  // remove+set of EVERY `--lab-*` var on every frame — the dominant DOM cost
+  // of an ease and pure churn for the style engine. The final style state is
+  // byte-identical to a full rewrite (locked by the golden fingerprints in
+  // test/hotpath-parity.test.mjs). Every adopt nulls `written`, so key-set
+  // changes and any external clobbering self-heal at the next solve — the same
+  // guarantee the always-full-rewrite gave, which also wrote nothing between
+  // eases while steady.
+  let written = null;
+  const applyHexes = (overlay) => {
+    const vars = { ...baseVars, ...overlay };
+    if (written === null) {
+      applyTheme(target, { vars });
+    } else {
+      for (const k in vars) {
+        const v = vars[k];
+        if (written[k] !== v) target.style.setProperty(k, v);
+      }
+    }
+    written = vars;
+  };
 
   // Apply the canonical set as-is (no ease in flight): color roles show their
   // oklch form, translucent roles their tint+alpha.
@@ -267,7 +318,9 @@ export function adaptTheme(element, options) {
     easing = new Map();
     for (const r of roles) {
       const from = fromByVar[r.cssVar] ?? r.hex;
-      if (from !== r.hex) easing.set(r.cssVar, { from, to: r.hex, held: 0 });
+      if (from !== r.hex) {
+        easing.set(r.cssVar, { from, to: r.hex, held: 0, pair: compileLerpPair(from, r.hex) });
+      }
     }
     easeStart = now;
     if (easing.size === 0) applyRolesDirect();
@@ -284,8 +337,11 @@ export function adaptTheme(element, options) {
   // colour we have) and the recheck loop re-solves.
   const floorBlend = (seg, e, bgLums, floor) => {
     const legalAt = (blend) => {
-      const lum = relativeLuminanceHex(lerpHex(seg.from, seg.to, blend));
-      return bgLums.every((L) => wcagRatio(lum, L) >= floor);
+      const lum = segLum(seg, blend);
+      for (let i = 0; i < bgLums.length; i++) {
+        if (wcagRatio(lum, bgLums[i]) < floor) return false;
+      }
+      return true;
     };
     if (legalAt(e)) return e;
     let lo = e;
@@ -298,7 +354,21 @@ export function adaptTheme(element, options) {
     return hi; // hi is always legal (or blend 1, the most-legal we have)
   };
 
-  const stepEase = (now, samples) => {
+  // Per-key memo of the samples' WCAG luminances. Strict mode reads them in
+  // both `stepEase` and `paintedNow` within a tick, and across consecutive
+  // frames of a static backdrop mid-ease; the tick already computes the
+  // samples key, so this costs one map per DISTINCT backdrop, not per call.
+  let lumsKey = null;
+  let lums = null;
+  const bgLumsFor = (samples, key) => {
+    if (key !== lumsKey) {
+      lums = samples.map(wcagLuminanceCached);
+      lumsKey = key;
+    }
+    return lums;
+  };
+
+  const stepEase = (now, samples, key) => {
     const t = easeMs <= 0 ? 1 : (now - easeStart) / easeMs;
     // Terminate the ease when it is done (`t >= 1`) OR when the clock went
     // non-finite (a NaN/±∞ `now` making `t` non-finite): drop the segments and
@@ -315,7 +385,7 @@ export function adaptTheme(element, options) {
       return;
     }
     const e = easeOut(t);
-    const bgLums = strict ? samples.map(relativeLuminanceHex) : null;
+    const bgLums = strict ? bgLumsFor(samples, key) : null;
     // Overlay carries ONLY in-flight color roles (as interpolated hex); every
     // other role — non-eased color and all translucent — keeps its canonical
     // `baseVars` value under the merge in `applyHexes`.
@@ -336,7 +406,7 @@ export function adaptTheme(element, options) {
         blend = Math.max(floorBlend(seg, e, bgLums, r.legalFloor), seg.held);
         seg.held = blend;
       }
-      overlay[r.cssVar] = lerpHex(seg.from, seg.to, blend);
+      overlay[r.cssVar] = segHex(seg, blend);
     }
     applyHexes(overlay);
   };
@@ -360,10 +430,10 @@ export function adaptTheme(element, options) {
   // equals what is on screen, including the strict-mode `held` clamp — otherwise
   // an overlapping re-solve in strict mode would start one frame BELOW the
   // painted (floored) colour.
-  const paintedNow = (now, samples) => {
+  const paintedNow = (now, samples, key) => {
     const t = easeMs <= 0 ? 1 : (now - easeStart) / easeMs;
     const e = easeOut(t);
-    const bgLums = strict ? samples.map(relativeLuminanceHex) : null;
+    const bgLums = strict ? bgLumsFor(samples, key) : null;
     const vars = {};
     for (const r of roles) {
       const seg = easing.get(r.cssVar);
@@ -375,7 +445,7 @@ export function adaptTheme(element, options) {
         strict && r.legalFloor != null
           ? Math.max(floorBlend(seg, e, bgLums, r.legalFloor), seg.held)
           : e;
-      vars[r.cssVar] = lerpHex(seg.from, seg.to, blend);
+      vars[r.cssVar] = segHex(seg, blend);
     }
     return vars;
   };
@@ -383,25 +453,22 @@ export function adaptTheme(element, options) {
   const tick = (nowArg) => {
     const now = nowArg ?? clock();
     const samples = readSamples();
+    const key = samples.join("|");
     // Advance any in-flight ease first (against the live samples, so strict mode
     // holds the legal floor every frame as the backdrop keeps drifting under it).
-    if (easing.size > 0) stepEase(now, samples);
+    if (easing.size > 0) stepEase(now, samples, key);
 
     // Steady state: a static backdrop with no in-flight ease and no pending
     // breach needs no work. A PENDING breach keeps us live even on a static
     // backdrop, so the sustain timer can fire on one that changed once to a
     // failing value and then held.
-    const key = samples.join("|");
     if (key === lastKey && easing.size === 0 && breachSince === null) return;
     lastKey = key;
     if (roles.length === 0) return;
 
     // Cheap worst-case re-check: do the current colours still pass against every
     // sample? `worstIdx` is the hardest sample, the one to re-solve against.
-    const { breached, worstIdx } = recheckSamples(
-      roles.map((r) => r.hex),
-      samples,
-    );
+    const { breached, worstIdx } = recheckSamples(samples);
 
     if (!breached) {
       breachSince = null;
@@ -415,10 +482,10 @@ export function adaptTheme(element, options) {
     // sampled at `now`) — never the in-flight TARGET. Starting from the target
     // would SNAP the element to the old target for one frame before easing,
     // reintroducing flicker when a re-solve overlaps a previous ease.
-    const fromByVar = paintedNow(now, samples);
+    const fromByVar = paintedNow(now, samples, key);
     solveAndAdopt(samples[worstIdx], now);
     beginEase(fromByVar, now);
-    stepEase(now, samples);
+    stepEase(now, samples, key);
   };
 
   let rafId = null;

package/effective-bg.js

@@ -288,6 +288,141 @@ export function oklabLerp(from, to, t) {
   return toHex([linearToSrgb(lin[0]) * 255, linearToSrgb(lin[1]) * 255, linearToSrgb(lin[2]) * 255]);
 }
 
+// --- Compiled hot-path forms (package-internal) -----------------------------
+//
+// `adaptTheme` interpolates the SAME from/to pair on every frame of an ease,
+// and strict mode re-derives WCAG luminance from the interpolated colour up to
+// 14× per floored role per frame (`floorBlend`'s bisection). Doing that
+// through the string API means re-parsing both endpoints and round-tripping
+// through `#RRGGBB` text on every call — measured at ~85-90% of the ease-frame
+// budget (bench/hotpath.bench.mjs). These helpers compile a pair once and then
+// produce results BYTE-IDENTICAL to their string-path equivalents:
+//
+//   · `lerpPairHex(pair, t)`       ≡ `oklabLerp(from, to, t)`
+//   · `lerpPairLuminance(pair, t)` ≡ WCAG luminance of `oklabLerp(from, to, t)`
+//   · `wcagLuminanceCached(css)`   ≡ luminance of `parseCssColor(css) ?? black`
+//
+// (locked by test/hotpath-parity.test.mjs on randomised inputs). They are
+// consumed by `adapt-theme.js` and are NOT part of the public package surface
+// (`index.js` does not re-export them).
+
+const PARSE_CACHE_CAP = 256;
+const parseCache = new Map();
+
+/** `parseCssColor` behind a small bounded memo, for per-frame callers feeding
+ *  it recurring strings (computed-style values, backdrop samples, ease
+ *  endpoints). The cap is a blunt bound, not an LRU: a full cache is simply
+ *  cleared and refills within a frame — cheaper than eviction bookkeeping for
+ *  a working set that is a handful of strings. The cached arrays are SHARED —
+ *  package-internal callers must treat them as immutable. (The public
+ *  `parseCssColor` stays unmemoized and returns a fresh array per call.) */
+export function parseCssColorCached(css) {
+  let hit = parseCache.get(css);
+  if (hit === undefined) {
+    hit = parseCssColor(css);
+    if (parseCache.size >= PARSE_CACHE_CAP) parseCache.clear();
+    parseCache.set(css, hit);
+  }
+  return hit;
+}
+
+/** WCAG 2.1 relative luminance of r,g,b channels (0..255) — the normative
+ *  0.03928 / 12.92 / 2.4 constants, matching `adapt-theme`'s floor semantics. */
+function wcagLumChannels(r, g, b) {
+  const lin = (c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+
+const LUM_CACHE_CAP = 256;
+const lumCache = new Map();
+
+/** WCAG relative luminance of any colour string, memoised. Byte-equal to the
+ *  string path `adapt-theme` used per sample per frame: luminance of
+ *  `parseCssColor(css) ?? [0,0,0,1]` — i.e. unparseable input yields the
+ *  luminance of black, preserving the historical fallback. */
+export function wcagLuminanceCached(css) {
+  let lum = lumCache.get(css);
+  if (lum === undefined) {
+    const c = parseCssColorCached(css) ?? [0, 0, 0, 1];
+    lum = wcagLumChannels(c[0], c[1], c[2]);
+    if (lumCache.size >= LUM_CACHE_CAP) lumCache.clear();
+    lumCache.set(css, lum);
+  }
+  return lum;
+}
+
+/** Round a channel to the exact byte `toHex` would emit (non-finite → 0,
+ *  clamp, round) — keeps the numeric luminance path quantisation-identical to
+ *  the `#RRGGBB` round-trip it replaces. */
+function hexByte(v) {
+  return Math.round(clamp255(Number.isFinite(v) ? v : 0));
+}
+
+/**
+ * Compile a from/to colour pair for repeated interpolation. Returns `null`
+ * when either endpoint fails to parse — callers fall back to `oklabLerp`,
+ * which owns the unparseable-endpoint fallback semantics. The pair carries
+ * both endpoints' Oklab coordinates plus their exact `toHex` forms, so the
+ * per-frame work is one Oklab lerp + gamut map — no string parsing at all.
+ *
+ * @param {string} from  any colour string `parseCssColor` accepts
+ * @param {string} to    any colour string `parseCssColor` accepts
+ * @returns {{la:number[],lb:number[],aHex:string,bHex:string,aBytes:number[],bBytes:number[]} | null}
+ */
+export function compileLerpPair(from, to) {
+  const a = parseCssColorCached(from);
+  const b = parseCssColorCached(to);
+  if (!a || !b) return null;
+  return {
+    la: linearRgbToOklab(srgbToLinear(a[0] / 255), srgbToLinear(a[1] / 255), srgbToLinear(a[2] / 255)),
+    lb: linearRgbToOklab(srgbToLinear(b[0] / 255), srgbToLinear(b[1] / 255), srgbToLinear(b[2] / 255)),
+    aHex: toHex(a),
+    bHex: toHex(b),
+    aBytes: [hexByte(a[0]), hexByte(a[1]), hexByte(a[2])],
+    bBytes: [hexByte(b[0]), hexByte(b[1]), hexByte(b[2])],
+  };
+}
+
+/** Byte-identical to `oklabLerp(from, to, t)` for the pair's endpoints — the
+ *  same double-precision Oklab lerp on the same parsed channels, minus the
+ *  per-call re-parse. */
+export function lerpPairHex(pair, t) {
+  if (t <= 0) return pair.aHex;
+  if (t >= 1) return pair.bHex;
+  const la = pair.la;
+  const lb = pair.lb;
+  const lin = oklabToLinearRgb(
+    la[0] + (lb[0] - la[0]) * t,
+    la[1] + (lb[1] - la[1]) * t,
+    la[2] + (lb[2] - la[2]) * t,
+  );
+  return toHex([linearToSrgb(lin[0]) * 255, linearToSrgb(lin[1]) * 255, linearToSrgb(lin[2]) * 255]);
+}
+
+/** WCAG relative luminance of `lerpPairHex(pair, t)` WITHOUT the `#RRGGBB`
+ *  round-trip: channels are quantised to the exact bytes `toHex` would emit,
+ *  then fed to the normative formula — so strict-mode bisection over `t` is
+ *  ~20 flops instead of serialise + re-parse, at identical results. */
+export function lerpPairLuminance(pair, t) {
+  if (t <= 0) return wcagLumChannels(pair.aBytes[0], pair.aBytes[1], pair.aBytes[2]);
+  if (t >= 1) return wcagLumChannels(pair.bBytes[0], pair.bBytes[1], pair.bBytes[2]);
+  const la = pair.la;
+  const lb = pair.lb;
+  const lin = oklabToLinearRgb(
+    la[0] + (lb[0] - la[0]) * t,
+    la[1] + (lb[1] - la[1]) * t,
+    la[2] + (lb[2] - la[2]) * t,
+  );
+  return wcagLumChannels(
+    hexByte(linearToSrgb(lin[0]) * 255),
+    hexByte(linearToSrgb(lin[1]) * 255),
+    hexByte(linearToSrgb(lin[2]) * 255),
+  );
+}
+
 /**
  * Compose an ordered stack of colour layers (front-to-back) over an opaque base
  * into a single opaque `#RRGGBB`. Pure — no DOM. Exposed for testing and for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labpics/colors",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Framework-agnostic contrast engine: resolve accessible, perceptually-anchored colour roles for any background. WASM core, zero runtime dependencies.",
   "type": "module",
   "license": "MIT",

package/pkg/labcolors.d.ts

@@ -141,18 +141,8 @@ export type RoleRecipe =
 | { kind: "alpha-analog"; of: LadderSource; alpha: number }
 | { kind: "zero" };
 
-/** Именованный пресет ролей. Тонкий конфиг несёт `preset` вместо простыни `roles`. */
-export type RolePreset = "labui";
-
 /** Полный конфиг дизайн-системы клиента — вход loadConfig (JSON.stringify(config)). */
 export interface ThemeConfig {
-    /**
-     * Пресет ролей: наполняет словарь дизайн-системы целиком, чтобы клиент вносил
-     * ТОЛЬКО значения (якоря, ручки), не семантику. Тонкий конфиг задаёт `preset` и
-     * ОПУСКАЕТ `roles`/`aliases`. Задать `preset` вместе с непустыми `roles` —
-     * ошибка `invalid_config` (оверрайд отдельных ролей — не этот слой).
-     */
-    readonly preset?: RolePreset;
     readonly brand: ThemeAnchors;
     readonly neutral: {
         readonly anchors: { light: string; mid: string; dark: string };
@@ -177,7 +167,8 @@ export interface ThemeConfig {
         readonly chroma_fraction: number;
     };
     readonly themes: ReadonlyArray<{ name: string; preset: "srgb" | "dim" | "srgb-ic" | "dim-ic" }>;
-    /** Опускается в тонком конфиге (задан `preset`); иначе — полный словарь ролей. */
+    /** Словарь ролей дизайн-системы. Конфиг обязан нести собственные роли; пустой
+     *  контракт (без `roles` и `aliases`) отклоняется на загрузке. */
     readonly roles?: ReadonlyArray<{ name: string; recipe: RoleRecipe }>;
     readonly aliases?: ReadonlyArray<{ alias: string; target: string }>;
 }
@@ -213,6 +204,22 @@ export interface ResolvedTheme {
 export class LabColors {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * PROTOTYPE — NOT part of the public API (unlisted, `_`-prefixed; may change
+     * or be removed without notice). Recheck one foreground set against MANY
+     * background samples in a single call. The reactive controller's worst-case
+     * loop rechecks the same foregrounds against every sample of a varying
+     * backdrop; the dominant per-foreground CAM16 forward is background-
+     * independent, so this shares it across all samples instead of recomputing it
+     * per `recheckContrast` call.
+     *
+     * Returns a flat, background-major `Float64Array`: sample `s`, foreground `i`
+     * is at `(s * fgHexes.length + i) * 2` (`lc`) and `+1` (`wcagRatio`). The
+     * values are byte-identical to calling `recheckContrast(bgHexes[s], fgHexes,
+     * theme)` for each `s`. Wiring the runtime to it is an OWNER decision (it
+     * changes the controller↔engine call shape); it is measured, not adopted.
+     */
+    _recheckContrastMulti(bg_hexes: string[], fg_hexes: string[], theme: string): Float64Array;
     /**
      * Загрузить конфиг дизайн-системы (JSON по типу `ThemeConfig` из `.d.ts`).
      *
@@ -268,6 +275,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_labcolors_free: (a: number, b: number) => void;
+    readonly labcolors__recheckContrastMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly labcolors_loadConfig: (a: number, b: number, c: number, d: number) => void;
     readonly labcolors_muddiness: (a: number, b: number, c: number, d: number) => void;
     readonly labcolors_new: () => number;

package/pkg/labcolors.js

@@ -17,6 +17,49 @@ export class LabColors {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_labcolors_free(ptr, 0);
     }
+    /**
+     * PROTOTYPE — NOT part of the public API (unlisted, `_`-prefixed; may change
+     * or be removed without notice). Recheck one foreground set against MANY
+     * background samples in a single call. The reactive controller's worst-case
+     * loop rechecks the same foregrounds against every sample of a varying
+     * backdrop; the dominant per-foreground CAM16 forward is background-
+     * independent, so this shares it across all samples instead of recomputing it
+     * per `recheckContrast` call.
+     *
+     * Returns a flat, background-major `Float64Array`: sample `s`, foreground `i`
+     * is at `(s * fgHexes.length + i) * 2` (`lc`) and `+1` (`wcagRatio`). The
+     * values are byte-identical to calling `recheckContrast(bgHexes[s], fgHexes,
+     * theme)` for each `s`. Wiring the runtime to it is an OWNER decision (it
+     * changes the controller↔engine call shape); it is measured, not adopted.
+     * @param {string[]} bg_hexes
+     * @param {string[]} fg_hexes
+     * @param {string} theme
+     * @returns {Float64Array}
+     */
+    _recheckContrastMulti(bg_hexes, fg_hexes, theme) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(bg_hexes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(fg_hexes, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(theme, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.labcolors__recheckContrastMulti(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v4 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v4;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Загрузить конфиг дизайн-системы (JSON по типу `ThemeConfig` из `.d.ts`).
      *
@@ -183,24 +226,10 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_new_da52cf8fe3429cb2: function() {
-            const ret = new Object();
+        __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
-        },
-        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-            return ret;
         }, arguments); },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return addHeapObject(ret);
-        },
         __wbindgen_object_drop_ref: function(arg0) {
             takeObject(arg0);
         },

package/pkg/labcolors_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_labcolors_free: (a: number, b: number) => void;
+export const labcolors__recheckContrastMulti: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const labcolors_loadConfig: (a: number, b: number, c: number, d: number) => void;
 export const labcolors_muddiness: (a: number, b: number, c: number, d: number) => void;
 export const labcolors_new: () => number;