@aiquants/spreadsheet 0.8.0

package/src/model/conditionalFormat.ts

@@ -0,0 +1,805 @@
+/**
+ * @fileoverview Conditional-format vocabulary, the 2-D 256 × 256 bucket index, condition
+ * evaluation and the ONE painted-format seam (v0.8, ADR-13 — the `getConditionalFormats`
+ * capability). The consumer declares rules through `getConditionalFormats()`; the root builds
+ * `buildCfIndex(rules)` once per (rules identity, renderVersion) with a fresh `createCfMemo()`
+ * at the same key; every surface that needs a cell's PAINTED format (paint, autofit, editor,
+ * announcements, caret gate, `getPaintedFormat`) goes through `resolvePaintedFormat` = base
+ * (`getCellFormat`) ⊕ CF. React-free and total (spec 01 §8.2).
+ *
+ * Engine contract (each clause is load-bearing and mutation-gated):
+ * - 2-D BUCKET INDEX + COLUMN SLICE: rules are bucketed by 256-row band × 256-column band (key
+ *   `rowBand * 0x10000 + colBand`), each bucket materialised LAZILY on first touch by ONE ordered
+ *   scan of the rules array — an untouched bucket is absent from the Map, a whole-column rule
+ *   lands in one column band per touched row band, and every bucket list preserves GLOBAL rule
+ *   order (`stopIfTrue` depends on it). Inside a bucket every touched COLUMN gets its own slice
+ *   (key `rowBand * 2^32 + col`), materialised lazily by ONE ordered scan of the bucket list and
+ *   holding only the rules whose ranges intersect that column within the row band — a sheet of
+ *   ≤ 256 columns has one column band, so without the slice every whole-column rule would be
+ *   walked for every cell. `buildCfIndex` itself is O(1); materialisation costs O(rules) per
+ *   touched bucket + O(bucket) per touched column; per cell the walk is O(rules intersecting the
+ *   cell's column within its 256-row band) — for whole-column rules exactly the rules on that
+ *   column.
+ * - EVALUATION ORDER: the bucket is walked in array order; range containment is checked before
+ *   any evaluation (a rule outside the cell reads nothing); every TRUE rule contributes its
+ *   style, an EARLIER rule wins for a property both set (Excel precedence — first match per
+ *   property), and a true rule with `stopIfTrue` ends the walk.
+ * - LAZY TEXT: `readText` is the caller's once-only thunk and is called only by the conditions
+ *   that need the text (`cellValue`, `text`, `empty`, `notEmpty`, `colorScale`);
+ *   `customFormula` never reads it.
+ * - `cellValue`: numeric comparison (as doubles) when the text and every used bound satisfy the
+ *   strict decimal grammar of cellFormat.ts (`parseNumber` — the single source of "what is a
+ *   number"), else code-unit string comparison of the raw strings; `between` / `notBetween` are
+ *   inclusive and never match when `b` is missing; an op outside the vocabulary never matches.
+ * - `text`: exact, case-sensitive needle ops; `empty` / `notEmpty` test the empty string.
+ * - `colorScale`: the value is `parseNumber(text)` (non-numeric ⇒ the rule does not apply); a
+ *   point without `value` takes the extrema from `getRangeExtrema` — undeclared ⇒ the rule is
+ *   skipped (never substituted), declared ⇒ called once per range of the rule and memoised per
+ *   rule id, `null` from any range ⇒ skipped; the contribution is `{ ...style, background }`
+ *   with the sRGB-interpolated colour (`interpolateScale`: clamped linear map between the two
+ *   ends, inverted ends swapped as pairs, `mid` honoured only strictly inside the ends, an
+ *   unparseable colour or a non-finite bound ⇒ null).
+ * - `customFormula`: `evaluateFormula(formula, cell)` receives the rule's formula VERBATIM (no
+ *   reference shifting — the consumer owns relative semantics) when declared, memoised per
+ *   (rule id, row, col); truth = `true` or a finite non-zero number; undeclared ⇒ skipped.
+ * - FAIL-SOFT rules: an unknown condition type, an unknown op, empty / non-intersecting ranges
+ *   and an unparseable scale colour skip the rule whole; nothing is ever substituted. The only
+ *   fail-fast guard is a non-array rules argument (a consumer bug ⇒ RangeError).
+ * - MEMO: `CfMemo` holds the extrema, formula answers and per-cell strict-decimal text parses
+ *   (shared by cellValue and colorScale, stored as the finite double so the walk never
+ *   re-converts a canonical string) of one renderVersion; each Map is cleared whole when
+ *   it reaches CF_MEMO_LIMIT (4,096) entries. The numeric bounds of a `cellValue` condition
+ *   are parsed once per condition OBJECT (module WeakMap — the same immutability contract as
+ *   the painted-format intern), never once per cell, and stored as doubles too.
+ * - PAINTED-FORMAT INTERN: with no true rule the base is returned BY IDENTITY; otherwise the
+ *   merged format (`applyCfStyle` = `mergeFormat`: canonical, base identity when unchanged) is
+ *   interned per base object — by style identity when exactly one identity-stable style
+ *   contributed, else by the accumulated style's key — so an unchanged adapter answer yields
+ *   the IDENTICAL painted object across re-slices and index rebuilds (cellPaint's WeakMap hits).
+ *   Formats and rule styles are treated as immutable values (like cellPaint): a consumer that
+ *   mutates a style object in place must hand out a new object for the change to paint.
+ *   `getCellFormat` undeclared ⇒ undefined without touching the index (CF cannot exist without
+ *   the format capability — the mount-time RangeError of the root).
+ * - `widthRelevantRules`: the autofit pre-filter — rules whose style sets `bold` or `italic`
+ *   PLUS every `stopIfTrue` rule (a dropped rule can neither own a bold / italic property nor
+ *   end the walk, so the bold / italic outcome of the sliced walk equals the painted one exactly;
+ *   dropping a barrier would let autofit measure a font paint never applies), memoised by
+ *   rules-array identity and returning the input itself when every rule is relevant.
+ *
+ * 条件付き書式の語彙・2 次元 256 × 256 バケット索引・条件評価・唯一の塗り書式合流点 (v0.8、
+ * ADR-13 — getConditionalFormats 能力)。root が (rules identity, renderVersion) 毎に
+ * `buildCfIndex(rules)` と `createCfMemo()` を構築し、塗り書式を要する全面 (paint / autofit /
+ * エディタ / 読み上げ / キャレットゲート / getPaintedFormat) が `resolvePaintedFormat` = base
+ * (getCellFormat) ⊕ CF を通る。React 非依存・全域関数 (spec 01 §8.2)。
+ * エンジン契約 (全て変異検証で封印): 256 行帯 × 256 列帯の 2 次元バケット (キー
+ * `rowBand * 0x10000 + colBand`) を初回参照で規則配列の 1 回走査により遅延実体化 (未参照バケットは
+ * Map に無い、全列規則は触れた行帯の 1 列帯だけ、バケット内は大域規則順 — stopIfTrue の根拠、
+ * buildCfIndex は O(1))、バケット内は触れた列毎の列スライス (キー `rowBand * 2^32 + col`、バケット
+ * list の 1 回走査で遅延実体化、行帯内でその列と交差する規則だけ — 256 列以下のシートは列帯が 1 つ
+ * なので、スライス無しでは全列規則が全セルで走査される。実体化は触れたバケット毎 O(規則数) +
+ * 触れた列毎 O(バケット)、セル毎の walk は O(行帯内でその列と交差する規則) = 全列規則ならその列の
+ * 規則だけ)、評価は配列順で containment を先に検査し、真の規則は全て寄与 (同一
+ * プロパティは先勝ち = Excel 優先順、stopIfTrue の真で打ち切り)、readText は text を要する条件
+ * だけが呼ぶ (customFormula は読まない)、cellValue は text と使う境界が全て厳密 10 進なら double
+ * 比較・他は文字列比較 (between は両端含み、b 欠落は不成立、語彙外 op は不成立)、text は完全一致、
+ * colorScale は parseNumber 非該当なら不適用・value 省略点は getRangeExtrema (未宣言は規則
+ * スキップ、宣言時はレンジ毎 1 回 + 規則 id で memo、null はスキップ)・寄与は
+ * `{ ...style, background }` (sRGB 補間: 両端のクランプ線形・逆順は対で入替・mid は両端の内側だけ
+ * 有効・解釈不能な色 / 非有限境界は null)、customFormula は数式を原文のまま
+ * evaluateFormula(formula, cell) へ (参照シフトなし、(規則 id, row, col) で memo、真 = true か
+ * 有限非 0 数、未宣言はスキップ)、不正規則 (未知 type / op、空・非交差レンジ、解釈不能な色) は
+ * 丸ごとスキップ (代替なし、唯一の fail-fast は非配列の rules = RangeError)、memo は各 Map
+ * 4,096 件で全消去 (セル text の厳密 10 進解析も (row, col) 毎に memo し cellValue / colorScale が
+ * 共有 — walk が正準文字列を再変換しないよう有限 double で保持、cellValue の境界解析は条件 object
+ * 毎の WeakMap で同じく double 保持 — 塗り intern と同じ不変契約)、塗り書式は
+ * 真の規則なしなら base を identity で返し、あれば applyCfStyle
+ * (= mergeFormat) の結果を base object 毎に intern (単一の identity 安定 style は style
+ * identity、他は累積 style のキー) するため同じアダプタ答えは同一 object、getCellFormat 未宣言は
+ * 索引に触れず undefined、widthRelevantRules は bold / italic を設定する規則と stopIfTrue の規則の
+ * autofit 用事前抽出 (落とした規則は bold / italic を持たず walk も止めないため bold / italic の結果は
+ * 塗りと厳密一致、障壁を落とすと塗りが当てないフォントで計る。配列 identity で memo、全件該当なら
+ * 入力そのもの)。
+ */
+
+import { type CellCoord, type CellRange, rangeContains } from "./cellCoord.ts"
+import { type CellFormat, mergeFormat, parseNumber } from "./cellFormat.ts"
+import { normalizeColor } from "./cellPaint.ts"
+
+/** The Sheets subset a rule may paint: background / colour / four text traits. Borders, alignment and number formats are out of scope (deviation row). / 規則が塗れる Sheets 部分集合: 背景 / 文字色 / 4 つの文字特性。罫線・揃え・数値書式は範囲外 (逸脱行)。 */
+export type ConditionalFormatStyle = { background?: string; color?: string; bold?: boolean; italic?: boolean; underline?: boolean; strikethrough?: boolean }
+
+/** Ordered comparison vocabulary of `cellValue` (the same eight words as the validation engine); between / notBetween include both bounds. / cellValue の比較語彙 (検証エンジンと同じ 8 語)。between / notBetween は両端含み。 */
+export type CompareOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "between" | "notBetween"
+
+/** Needle vocabulary of the `text` condition (exact, case-sensitive). / text 条件の needle 語彙 (完全一致・大文字小文字区別)。 */
+export type CfTextOp = "contains" | "notContains" | "startsWith" | "endsWith"
+
+/** One colour-scale point; `value` omitted = the range extremum from `getRangeExtrema` (min / max) or the arithmetic midpoint (mid). / 色スケールの 1 点。value 省略 = getRangeExtrema のレンジ極値 (min / max) か算術中点 (mid)。 */
+export type ScalePoint = { color: string; value?: number }
+
+/** Numeric comparison when the text and the used bounds are strict decimals, else string comparison. / text と使う境界が厳密 10 進なら数値比較、他は文字列比較。 */
+export type CellValueCondition = { type: "cellValue"; op: CompareOp; a: string; b?: string }
+
+/** Case-sensitive needle test on the raw text. / 素の text に対する大文字小文字区別の needle 判定。 */
+export type TextCondition = { type: "text"; op: CfTextOp; value: string }
+
+/** The text is the empty string. / text が空文字。 */
+export type EmptyCondition = { type: "empty" }
+
+/** The text is not the empty string. / text が空文字でない。 */
+export type NotEmptyCondition = { type: "notEmpty" }
+
+/** sRGB interpolation between two or three points over the numeric value; non-numeric text does not apply. / 数値に対する 2 点または 3 点の sRGB 補間。非数値 text は不適用。 */
+export type ColorScaleCondition = { type: "colorScale"; min: ScalePoint; mid?: ScalePoint; max: ScalePoint }
+
+/** `adapter.evaluateFormula(formula, cell)` verbatim; truth = `true` or a finite non-zero number. / evaluateFormula(formula, cell) を原文のまま。真 = true か有限非 0 数。 */
+export type CustomFormulaCondition = { type: "customFormula"; formula: string }
+
+/** The condition vocabulary (six members). / 条件の語彙 (6 メンバー)。 */
+export type CfCondition = CellValueCondition | TextCondition | EmptyCondition | NotEmptyCondition | ColorScaleCondition | CustomFormulaCondition
+
+/** One rule as the consumer stores it: consumer-scoped `id`, the ranges it applies to, its condition, the style it paints, and whether a match ends the walk. / consumer が保持する規則 1 件: consumer スコープの id、適用レンジ、条件、塗る style、真で打ち切るか。 */
+export type ConditionalFormatRule = { id: string; ranges: readonly CellRange[]; condition: CfCondition; style: ConditionalFormatStyle; stopIfTrue?: boolean }
+
+/** One rule as a paste hands it to the consumer (`PasteEditContext.conditionalFormats`): the source rule's id travels as `sourceRuleId`, the consumer mints the new id. / paste が consumer へ渡す規則 1 件: 元規則の id は sourceRuleId、新 id は consumer が採番。 */
+export type ConditionalFormatRuleInput = { sourceRuleId: string; ranges: readonly CellRange[]; condition: CfCondition; style: ConditionalFormatStyle; stopIfTrue?: boolean }
+
+/** Numeric extrema of a range (the `getRangeExtrema` answer). / レンジの数値極値 (getRangeExtrema の答え)。 */
+export type RangeExtrema = { min: number; max: number }
+
+/** What `evaluateFormula` may answer. / evaluateFormula が返し得る値。 */
+export type FormulaValue = string | number | boolean | null
+
+/**
+ * The three adapter reads this engine performs — a structural subset of SpreadsheetDataAdapter
+ * (any adapter is passable; declaring a member is the capability branch, not a fallback).
+ * このエンジンが行うアダプタ読み 3 種 — SpreadsheetDataAdapter の構造的部分集合 (どのアダプタも
+ * 渡せる。メンバー宣言が能力分岐であり、フォールバックではない)。
+ */
+export type ConditionalFormatAdapter = {
+    getCellFormat?: (row: number, col: number) => CellFormat | undefined
+    getRangeExtrema?: (range: CellRange) => RangeExtrema | null
+    evaluateFormula?: (formula: string, cell: CellCoord) => FormulaValue
+}
+
+/** Rows per bucket band. / バケット行帯の行数。 */
+export const CF_BUCKET_ROWS = 256
+
+/** Columns per bucket band. / バケット列帯の列数。 */
+export const CF_BUCKET_COLS = 256
+
+/** Multiplier of the row band in a column-slice key (`rowBand * 2^32 + col`): columns below 2^32 and row bands below 2^21 keep the key exact in a double. / 列スライスキー (`rowBand * 2^32 + col`) の行帯乗数: 列 < 2^32・行帯 < 2^21 でキーは double で正確。 */
+const COLUMN_KEY_BASE = 2 ** 32
+
+/** Whole-Map clearing threshold of every bounded memo here (the CfMemo maps, the painted-format key intern). / ここにある有界 memo (CfMemo の Map、塗り書式のキー intern) の全消去しきい値。 */
+export const CF_MEMO_LIMIT = 4096
+
+/**
+ * The 2-D bucket index: `rules` in global order, the lazily materialised buckets keyed by
+ * `rowBand * 0x10000 + colBand` (row / column bands of 256) and the lazily materialised column
+ * slices keyed by `rowBand * 2^32 + col`. A bucket list holds, in global order, every rule with
+ * a range intersecting the bucket rectangle; a column slice holds, in global order, the rules of
+ * the bucket whose ranges intersect that one column within the row band; each Map holds only the
+ * entries touched so far.
+ * 2 次元バケット索引: 大域順の `rules`、`rowBand * 0x10000 + colBand` (256 行帯 / 列帯) をキーに
+ * 遅延実体化するバケット、`rowBand * 2^32 + col` をキーに遅延実体化する列スライス。バケットの
+ * list はバケット矩形と交差する規則を大域順で持ち、列スライスはそのバケットのうち行帯内でその
+ * 1 列と交差する規則を大域順で持ち、各 Map には参照済みの項目だけがある。
+ */
+export type CfIndex = { readonly rules: readonly ConditionalFormatRule[]; readonly buckets: Map<number, readonly ConditionalFormatRule[]>; readonly columns: Map<number, readonly ConditionalFormatRule[]> }
+
+/**
+ * The bounded per-renderVersion memo: `extrema` per rule id (colorScale — a `null` answer is a
+ * memoised "no numeric value"), `formulas` per `rule id \u0000 row \u0000 col` (customFormula),
+ * `numbers` per `row \u0000 col` (the strict-decimal parse of the cell's text as its finite
+ * double — a `null` answer is a memoised "not a number"; cellValue and colorScale share it, so a
+ * walk of N rules parses the text once, not N times, and never re-converts a canonical string).
+ * Each Map is cleared whole when it reaches CF_MEMO_LIMIT.
+ * renderVersion 毎の有界 memo: `extrema` は規則 id 毎 (colorScale — null も「数値なし」の登録済み
+ * 答え)、`formulas` は `規則 id \u0000 row \u0000 col` 毎 (customFormula)、`numbers` は
+ * `row \u0000 col` 毎 (セル text の厳密 10 進解析の有限 double — null も「非数値」の登録済み答え。
+ * cellValue と colorScale が共有し、N 規則の walk でも解析は 1 回で正準文字列の再変換もなし)。
+ * 各 Map は CF_MEMO_LIMIT で全消去。
+ */
+export type CfMemo = { readonly extrema: Map<string, RangeExtrema | null>; readonly formulas: Map<string, FormulaValue>; readonly numbers: Map<string, number | null> }
+
+/** Shared frozen empty list so empty buckets / empty answers never allocate. / 空バケット / 空答えが確保しない共有の凍結空配列。 */
+const EMPTY_RULES: readonly ConditionalFormatRule[] = Object.freeze([])
+
+/** The style keys in a fixed order (the accumulated-style intern key and the earlier-wins overlay iterate it). / 固定順の style キー (累積 style の intern キーと先勝ち合成が走査)。 */
+const STYLE_KEYS = ["background", "color", "bold", "italic", "underline", "strikethrough"] as const satisfies readonly (keyof ConditionalFormatStyle)[]
+
+/** Compile-time proof that STYLE_KEYS lists EVERY style key (a key added to the type but not here would be silently dropped by the overlay). / STYLE_KEYS が全 style キーを網羅することの型水準の証明 (型に増えたキーが表に無いと合成で黙って落ちる)。 */
+const styleKeysCoverEveryKey: [Exclude<keyof ConditionalFormatStyle, (typeof STYLE_KEYS)[number]>] extends [never] ? true : never = true
+void styleKeysCoverEveryKey
+
+/** Fail-fast guard shared by the two array-taking entry points (a non-array would silently mean "no rules"). / 配列を取る 2 つの入口が共有する fail-fast (非配列は黙って「規則なし」になってしまう)。 */
+const assertRules = (rules: readonly ConditionalFormatRule[], fn: string): void => {
+    if (!Array.isArray(rules)) {
+        throw new RangeError(`[spreadsheet] ${fn} requires an array of conditional-format rules, received ${typeof rules}`)
+    }
+}
+
+/**
+ * Registers a memo / index value, clearing the whole Map first when it has reached
+ * CF_MEMO_LIMIT; returns the value. Correct for every Map here because each entry is a pure
+ * function of its key (plus the rules array / renderVersion the Map is scoped to) — a cleared
+ * entry recomputes identically on its next touch.
+ * memo / 索引値を登録 (CF_MEMO_LIMIT 到達時は先に全消去)、値を返す。ここにある全 Map で正しい
+ * のは、各項目がキー (と Map のスコープである rules 配列 / renderVersion) の純関数であるため —
+ * 消去された項目は次の参照で同一内容に再計算される。
+ */
+const memoSet = <K, V>(map: Map<K, V>, key: K, value: V): V => {
+    // 上限到達で全消去 (個別追い出しの帳簿を持たない — 語彙は renderVersion 単位で有限)
+    if (map.size >= CF_MEMO_LIMIT) {
+        map.clear()
+    }
+    map.set(key, value)
+    return value
+}
+
+/**
+ * Builds the 2-D bucket index for one rules array — O(1): buckets and column slices materialise
+ * lazily on first touch (`rulesForCell` / `resolvePaintedFormat`). Build once per (rules
+ * identity, renderVersion); the index never re-reads the array after a bucket is materialised.
+ * 規則配列 1 つの 2 次元バケット索引を構築 — O(1): バケットと列スライスは初回参照 (rulesForCell /
+ * resolvePaintedFormat) で遅延実体化。(rules identity, renderVersion) 毎に 1 回構築し、実体化後は
+ * 配列を再読しない。
+ */
+export const buildCfIndex = (rules: readonly ConditionalFormatRule[]): CfIndex => {
+    assertRules(rules, "buildCfIndex")
+    return { rules, buckets: new Map(), columns: new Map() }
+}
+
+/** Whether any range of the rule intersects the bucket rectangle (a NaN field compares false, so a malformed range never indexes). / 規則のいずれかのレンジがバケット矩形と交差するか (NaN は比較 false で不正レンジは索引されない)。 */
+const intersectsBucket = (ranges: readonly CellRange[], top: number, bottom: number, left: number, right: number): boolean => {
+    for (const range of ranges) {
+        if (range.startRow <= bottom && range.endRow >= top && range.startCol <= right && range.endCol >= left) {
+            return true
+        }
+    }
+    return false
+}
+
+/** The bucket list of the cell, materialised on first touch by one ordered scan of `rules` and stored in the bounded buckets Map (memoSet — cleared whole at CF_MEMO_LIMIT). / セルのバケット list (初回参照で rules を 1 回順走査して実体化し、有界の buckets Map へ登録 — memoSet が CF_MEMO_LIMIT で全消去)。 */
+const bucketFor = (index: CfIndex, row: number, col: number): readonly ConditionalFormatRule[] => {
+    const rowBand = Math.floor(row / CF_BUCKET_ROWS)
+    const colBand = Math.floor(col / CF_BUCKET_COLS)
+    const key = rowBand * 0x10000 + colBand
+    const hit = index.buckets.get(key)
+    if (hit !== undefined) {
+        return hit
+    }
+    // 初回参照: 規則配列を 1 回だけ順に走査し、バケット矩形と交差する規則を配列順のまま積む (大域規則順の保存 — stopIfTrue の根拠)
+    const top = rowBand * CF_BUCKET_ROWS
+    const left = colBand * CF_BUCKET_COLS
+    const list: ConditionalFormatRule[] = []
+    for (const rule of index.rules) {
+        if (intersectsBucket(rule.ranges, top, top + CF_BUCKET_ROWS - 1, left, left + CF_BUCKET_COLS - 1)) {
+            list.push(rule)
+        }
+    }
+    // 有界登録 — 索引 Map を無限に育てると編集なしの長時間スクロールが冷メモだけでヒープを単調に増やす
+    return memoSet(index.buckets, key, list.length === 0 ? EMPTY_RULES : list)
+}
+
+/**
+ * The column slice of the cell — the rules of its bucket whose ranges intersect the cell's
+ * column within the 256-row band, in global order — materialised on first touch by one ordered
+ * scan of the bucket list (never of the rules array) and stored in the bounded columns Map
+ * (memoSet — cleared whole at CF_MEMO_LIMIT). The shared frozen empty list when none.
+ * セルの列スライス — そのバケットのうち 256 行帯内でセルの列と交差する規則を大域順で —
+ * 初回参照でバケット list を 1 回順走査して実体化し (規則配列は走査しない)、有界の columns Map
+ * へ登録 (memoSet が CF_MEMO_LIMIT で全消去)。無ければ共有の凍結空配列。
+ */
+const columnSliceFor = (index: CfIndex, row: number, col: number): readonly ConditionalFormatRule[] => {
+    const rowBand = Math.floor(row / CF_BUCKET_ROWS)
+    const key = rowBand * COLUMN_KEY_BASE + col
+    const hit = index.columns.get(key)
+    if (hit !== undefined) {
+        return hit
+    }
+    // 初回参照: バケット (必要なら実体化) を 1 回だけ順走査し、行帯内でこの 1 列と交差する規則を配列順のまま積む (大域規則順の保存)
+    const bucket = bucketFor(index, row, col)
+    const top = rowBand * CF_BUCKET_ROWS
+    const list: ConditionalFormatRule[] = []
+    for (const rule of bucket) {
+        if (intersectsBucket(rule.ranges, top, top + CF_BUCKET_ROWS - 1, col, col)) {
+            list.push(rule)
+        }
+    }
+    // 有界登録 — 列スライスは rowBands × cols の幾何上限まで育ち得るため、バケット以上に有界化が効く
+    return memoSet(index.columns, key, list.length === 0 ? EMPTY_RULES : list)
+}
+
+/** Whether any range of the rule contains the cell. / 規則のいずれかのレンジがセルを含むか。 */
+const containsCell = (ranges: readonly CellRange[], cell: CellCoord): boolean => {
+    for (const range of ranges) {
+        if (rangeContains(range, cell)) {
+            return true
+        }
+    }
+    return false
+}
+
+/**
+ * The rules whose ranges contain the cell, in global rule order — the cell's column slice
+ * (bucket and slice materialised on first touch) narrowed by range containment. A shared frozen
+ * empty list when none.
+ * セルを含むレンジを持つ規則を大域規則順で — セルの列スライス (バケットとスライスは初回参照で
+ * 実体化) を containment で絞る。無ければ共有の凍結空配列。
+ */
+export const rulesForCell = (index: CfIndex, row: number, col: number): readonly ConditionalFormatRule[] => {
+    const slice = columnSliceFor(index, row, col)
+    if (slice.length === 0) {
+        return slice
+    }
+    const cell: CellCoord = { row, col }
+    const out = slice.filter((rule) => containsCell(rule.ranges, cell))
+    return out.length === 0 ? EMPTY_RULES : out
+}
+
+/** A fresh empty memo (one per renderVersion). / 新しい空 memo (renderVersion 毎に 1 つ)。 */
+export const createCfMemo = (): CfMemo => ({ extrema: new Map(), formulas: new Map(), numbers: new Map() })
+
+/** Three-way comparison of two values of the same primitive kind. / 同種原始値 2 つの三値比較。 */
+const order = <T extends number | string>(x: T, y: T): -1 | 0 | 1 => (x < y ? -1 : x > y ? 1 : 0)
+
+/** The op verdict from the text's order against `a` (and against `b` — null when unused or missing). / text の a との順序 (と b との順序 — 未使用 / 欠落は null) からの op 判定。 */
+const verdict = (op: CompareOp, toA: -1 | 0 | 1, toB: -1 | 0 | 1 | null): boolean => {
+    switch (op) {
+        case "eq":
+            return toA === 0
+        case "neq":
+            return toA !== 0
+        case "gt":
+            return toA > 0
+        case "gte":
+            return toA >= 0
+        case "lt":
+            return toA < 0
+        case "lte":
+            return toA <= 0
+        case "between":
+            return toB !== null && toA >= 0 && toB <= 0
+        case "notBetween":
+            return toB !== null && (toA < 0 || toB > 0)
+        default:
+            // 語彙外の op は不成立 (fail-soft)
+            return false
+    }
+}
+
+/** The parsed numeric bounds of one cellValue condition as finite doubles (`null` = not a strict decimal, or `b` absent). / cellValue 条件 1 件の解析済み数値境界 (有限 double、null = 厳密 10 進でない、または b 不在)。 */
+type ParsedBounds = { readonly a: number | null; readonly b: number | null }
+
+/** Bounds memo keyed by condition-object identity (conditions are immutable values, like styles / formats). / 条件 object identity をキーとする境界 memo (条件は style / 書式と同じ不変値)。 */
+const boundsMemo = new WeakMap<CellValueCondition, ParsedBounds>()
+
+/** The finite double of a strict-decimal parse (`null` passes through) — the hot walk compares doubles, never canonical strings. / 厳密 10 進解析の有限 double (null はそのまま) — ホットな walk は正準文字列でなく double を比較。 */
+const toDouble = (parsed: Intl.StringNumericLiteral | null): number | null => (parsed === null ? null : Number(parsed))
+
+/**
+ * The numeric bounds of a cellValue condition, parsed ONCE per condition object — a whole-column
+ * rule walked over 1,200 window cells re-parses nothing (the dominant redundant cost of the
+ * cellValue walk). The WeakMap relies on the same immutability contract as the painted-format
+ * intern: an in-place mutation of a condition must hand out a new object to take effect.
+ * cellValue 条件の数値境界を条件 object 毎に 1 回だけ解析 — 全列規則が窓 1,200 セルを歩いても
+ * 再解析ゼロ (cellValue walk の支配的な冗長コスト)。WeakMap は塗り intern と同じ不変契約に依拠:
+ * 条件の in-place 変更は新 object の払い出しで初めて効く。
+ */
+const parsedBounds = (condition: CellValueCondition): ParsedBounds => {
+    const hit = boundsMemo.get(condition)
+    if (hit !== undefined) {
+        return hit
+    }
+    const b = condition.b
+    const bounds: ParsedBounds = { a: toDouble(parseNumber(condition.a)), b: b === undefined ? null : toDouble(parseNumber(b)) }
+    boundsMemo.set(condition, bounds)
+    return bounds
+}
+
+/**
+ * The memoised strict-decimal parse of the cell's text as its finite double — once per
+ * (row, col) per memo (bounded via memoSet), shared by every cellValue and colorScale rule of
+ * the cell's walk (which then compares / interpolates the double with no further conversion).
+ * Text is stable within a renderVersion (the same contract `formulas` / `extrema` already rely
+ * on).
+ * セル text の厳密 10 進解析の有限 double の memo — memo につき (row, col) 毎に 1 回 (memoSet で
+ * 有界)。セルの walk 上の全 cellValue / colorScale 規則が共有し、追加変換なしで double を比較 /
+ * 補間。text は renderVersion 内で安定 (`formulas` / `extrema` が既に依拠する契約と同一)。
+ */
+const cellNumber = (memo: CfMemo, cell: CellCoord, readText: () => string): number | null => {
+    const key = `${cell.row}\u0000${cell.col}`
+    const cached = memo.numbers.get(key)
+    // null も「非数値」の登録済み答え — undefined だけが未登録 (undefined は決して格納しない)
+    if (cached !== undefined) {
+        return cached
+    }
+    return memoSet(memo.numbers, key, toDouble(parseNumber(readText())))
+}
+
+/** `cellValue`: double comparison when the text and every used bound are strict decimals, else string comparison of the raw strings; the text double is memoised per (row, col) and the bound doubles per condition object. / cellValue: text と使う境界が全て厳密 10 進なら double 比較、他は素の文字列比較。text の double は (row, col) 毎、境界の double は条件 object 毎に memo。 */
+const matchCellValue = (condition: CellValueCondition, cell: CellCoord, readText: () => string, memo: CfMemo): boolean => {
+    const usesB = condition.op === "between" || condition.op === "notBetween"
+    const bounds = parsedBounds(condition)
+    const numText = cellNumber(memo, cell, readText)
+    const numB = usesB ? bounds.b : null
+    // 数値モード: text と使う境界が全て厳密 10 進 (double 比較 — 表示エンジンの十分条件)
+    if (numText !== null && bounds.a !== null && (!usesB || numB !== null)) {
+        return verdict(condition.op, order(numText, bounds.a), numB === null ? null : order(numText, numB))
+    }
+    // 文字列モード: 素の文字列のコード単位順 (trim もしない)。両端 op の b 欠落は null の toB として verdict が不成立にする (書きかけの規則は塗らない)
+    const text = readText()
+    const b = condition.b
+    return verdict(condition.op, order(text, condition.a), b === undefined ? null : order(text, b))
+}
+
+/** `text`: exact, case-sensitive needle ops; an op outside the vocabulary never matches. / text: 完全一致の needle op。語彙外 op は不成立。 */
+const matchText = (condition: TextCondition, text: string): boolean => {
+    switch (condition.op) {
+        case "contains":
+            return text.includes(condition.value)
+        case "notContains":
+            return !text.includes(condition.value)
+        case "startsWith":
+            return text.startsWith(condition.value)
+        case "endsWith":
+            return text.endsWith(condition.value)
+        default:
+            // 語彙外の op は不成立 (fail-soft)
+            return false
+    }
+}
+
+/** A colour as four 0-255 channels (alpha 255 when opaque). / 色を 0-255 の 4 チャネルで (不透明は alpha 255)。 */
+type Rgba = readonly [number, number, number, number]
+
+/** Parses through the paint engine's normaliser so every colour form it accepts interpolates; null when it rejects the text. / 塗りエンジンの正規化を通し、受理される全色形を補間可能にする。拒否は null。 */
+const parseRgba = (color: string): Rgba | null => {
+    const hex = normalizeColor(color)
+    if (hex === null) {
+        return null
+    }
+    // "#rrggbb" か "#rrggbbaa" (不透明 alpha は 6 桁に畳まれている)
+    const channel = (at: number): number => Number.parseInt(hex.slice(at, at + 2), 16)
+    return [channel(1), channel(3), channel(5), hex.length === 9 ? channel(7) : 255]
+}
+
+/** One channel → two lowercase hex digits. / 1 チャネル → 小文字 16 進 2 桁。 */
+const byteToHex = (value: number): string => value.toString(16).padStart(2, "0")
+
+/** Linear sRGB blend at `t` ∈ [0, 1], rounded per channel; opaque results collapse to six digits (the paint engine's canonical spelling). / t ∈ [0, 1] の線形 sRGB 混合 (チャネル毎に丸め)。不透明は 6 桁へ畳む (塗りエンジンの正準綴り)。 */
+const blend = (from: Rgba, to: Rgba, t: number): string => {
+    const at = (i: 0 | 1 | 2 | 3): number => Math.round(from[i] + (to[i] - from[i]) * t)
+    const rgb = `#${byteToHex(at(0))}${byteToHex(at(1))}${byteToHex(at(2))}`
+    const alpha = at(3)
+    return alpha === 255 ? rgb : `${rgb}${byteToHex(alpha)}`
+}
+
+/** Position of `value` in [a, b] clamped to [0, 1]; a degenerate segment (a === b) maps values at or below it to 0 and the rest to 1. / [a, b] 内の value の位置を [0, 1] にクランプ。退化区間 (a === b) は a 以下を 0、他を 1。 */
+const ratio = (value: number, a: number, b: number): number => (a === b ? (value <= a ? 0 : 1) : Math.min(1, Math.max(0, (value - a) / (b - a))))
+
+/**
+ * sRGB interpolation between scale points: a point without `value` takes the corresponding
+ * extremum (`mid` without `value` = the arithmetic midpoint); ends given in inverted order are
+ * swapped as (value, colour) pairs; `mid` is honoured only when its value lies strictly between
+ * the ends; the value is clamped to the ends. Null (the rule does not apply) when the value or a
+ * used bound is not finite, or any point's colour does not normalise.
+ * スケール点間の sRGB 補間: value 省略点は対応する極値 (mid の省略は算術中点)、逆順の両端は
+ * (value, 色) の対で入替、mid は両端の厳密な内側にあるときだけ有効、value は両端でクランプ。
+ * value / 使う境界が非有限、またはいずれかの点の色が正規化できなければ null (規則は不適用)。
+ */
+export const interpolateScale = (value: number, min: ScalePoint, mid: ScalePoint | undefined, max: ScalePoint, extrema: RangeExtrema): string | null => {
+    let lo = min.value === undefined ? extrema.min : min.value
+    let hi = max.value === undefined ? extrema.max : max.value
+    let colorLo = parseRgba(min.color)
+    let colorHi = parseRgba(max.color)
+    const colorMid = mid === undefined ? undefined : parseRgba(mid.color)
+    // 非有限の値 / 境界、正規化できない色はどれも補間不能 — 規則は不適用 (代替色を作らない)
+    const finite = Number.isFinite(value) && Number.isFinite(lo) && Number.isFinite(hi)
+    if (!finite || colorLo === null || colorHi === null || colorMid === null) {
+        return null
+    }
+    // 逆順の両端は (value, 色) の対で入替え、以後は昇順軸で扱う (min 側の色は min 側の値に付いたまま)
+    if (lo > hi) {
+        const swapValue = lo
+        lo = hi
+        hi = swapValue
+        const swapColor = colorLo
+        colorLo = colorHi
+        colorHi = swapColor
+    }
+    if (mid !== undefined && colorMid !== undefined) {
+        const m = mid.value === undefined ? (lo + hi) / 2 : mid.value
+        // 中間点は両端の厳密な内側にあるときだけ 2 区間補間 (外側 / 一致 / 非有限は 2 点補間へ)
+        if (lo < m && m < hi) {
+            return value <= m ? blend(colorLo, colorMid, ratio(value, lo, m)) : blend(colorMid, colorHi, ratio(value, m, hi))
+        }
+    }
+    return blend(colorLo, colorHi, ratio(value, lo, hi))
+}
+
+/**
+ * The extrema a colorScale rule interpolates over, memoised per rule id: both `value`s given ⇒
+ * those values (no adapter read); otherwise `getRangeExtrema` once per range of the rule
+ * (undeclared ⇒ null, never substituted; a `null` answer from any range ⇒ null, memoised).
+ * colorScale 規則が補間する極値 (規則 id で memo): 両 value 指定ならその値 (アダプタ読みなし)、
+ * 他は規則のレンジ毎に getRangeExtrema 1 回 (未宣言は null で代替なし、いずれかの null 答えは
+ * null として memo)。
+ */
+const resolveExtrema = (rule: ConditionalFormatRule, condition: ColorScaleCondition, adapter: ConditionalFormatAdapter, memo: CfMemo): RangeExtrema | null => {
+    const cached = memo.extrema.get(rule.id)
+    // null も「数値なし」の登録済み答え — undefined だけが未登録 (undefined は決して格納しない)
+    if (cached !== undefined) {
+        return cached
+    }
+    const { min, max } = condition
+    // 両端の value が揃えばそれが極値 — アダプタは読まない
+    if (min.value !== undefined && max.value !== undefined) {
+        return memoSet(memo.extrema, rule.id, { min: min.value, max: max.value })
+    }
+    // 能力分岐: getRangeExtrema 未宣言なら規則ごとスキップ (代替値を作らない)
+    if (adapter.getRangeExtrema === undefined) {
+        return null
+    }
+    let lo = Number.POSITIVE_INFINITY
+    let hi = Number.NEGATIVE_INFINITY
+    for (const range of rule.ranges) {
+        const answer = adapter.getRangeExtrema(range)
+        // いずれかのレンジに数値が無ければ規則全体が不適用 (memo して再読しない)
+        if (answer === null) {
+            return memoSet(memo.extrema, rule.id, null)
+        }
+        lo = Math.min(lo, answer.min)
+        hi = Math.max(hi, answer.max)
+    }
+    return memoSet(memo.extrema, rule.id, { min: lo, max: hi })
+}
+
+/** The interpolated background of a colorScale rule for the cell, or null when the rule does not apply; the text parse is the per-(row, col) memo shared with cellValue. / colorScale 規則のセルに対する補間背景色、不適用なら null。text の解析は cellValue と共有の (row, col) memo。 */
+const scaleBackground = (rule: ConditionalFormatRule, condition: ColorScaleCondition, cell: CellCoord, readText: () => string, adapter: ConditionalFormatAdapter, memo: CfMemo): string | null => {
+    const parsed = cellNumber(memo, cell, readText)
+    // 非数値 text には色スケールが無い
+    if (parsed === null) {
+        return null
+    }
+    const extrema = resolveExtrema(rule, condition, adapter, memo)
+    if (extrema === null) {
+        return null
+    }
+    return interpolateScale(parsed, condition.min, condition.mid, condition.max, extrema)
+}
+
+/** `customFormula` truth for the cell: the memoised `evaluateFormula(formula, cell)` answer is `true` or a finite non-zero number; undeclared ⇒ false. / customFormula のセルに対する真偽: memo 済み evaluateFormula(formula, cell) の答えが true か有限非 0 数。未宣言は false。 */
+const formulaTruth = (rule: ConditionalFormatRule, condition: CustomFormulaCondition, cell: CellCoord, adapter: ConditionalFormatAdapter, memo: CfMemo): boolean => {
+    // 能力分岐: evaluateFormula 未宣言なら規則ごとスキップ
+    if (adapter.evaluateFormula === undefined) {
+        return false
+    }
+    const key = `${rule.id}\u0000${cell.row}\u0000${cell.col}`
+    const cached = memo.formulas.get(key)
+    // FormulaValue は undefined を含まないので undefined だけが未登録 (null / false は登録済みの答え)
+    const value = cached !== undefined ? cached : memoSet(memo.formulas, key, adapter.evaluateFormula(condition.formula, cell))
+    return value === true || (typeof value === "number" && Number.isFinite(value) && value !== 0)
+}
+
+/**
+ * Evaluates one rule for one cell: the rule's `style` BY IDENTITY when the condition holds
+ * (colorScale: a fresh `{ ...style, background }` with the interpolated colour), null when it
+ * does not or the rule is skipped (unknown type / op, undeclared capability, non-numeric text
+ * for a scale, unparseable scale colour). `readText` is called only by conditions that need the
+ * text; the memo serves `getRangeExtrema` / `evaluateFormula` and the per-(row, col) text parse
+ * of `cellValue` / `colorScale`.
+ * 規則 1 件をセル 1 つで評価: 条件成立なら規則の `style` を identity で (colorScale は補間色を
+ * 載せた新規 `{ ...style, background }`)、不成立 / スキップ (未知 type / op、能力未宣言、スケールの
+ * 非数値 text、解釈不能なスケール色) なら null。readText は text を要する条件だけが呼び、memo は
+ * getRangeExtrema / evaluateFormula と cellValue / colorScale の (row, col) 毎 text 解析に仕える。
+ */
+export const evaluateCondition = (rule: ConditionalFormatRule, cell: CellCoord, readText: () => string, adapter: ConditionalFormatAdapter, memo: CfMemo): ConditionalFormatStyle | null => {
+    const condition = rule.condition
+    switch (condition.type) {
+        case "cellValue":
+            return matchCellValue(condition, cell, readText, memo) ? rule.style : null
+        case "text":
+            return matchText(condition, readText()) ? rule.style : null
+        case "empty":
+            return readText() === "" ? rule.style : null
+        case "notEmpty":
+            return readText() !== "" ? rule.style : null
+        case "colorScale": {
+            const background = scaleBackground(rule, condition, cell, readText, adapter, memo)
+            return background === null ? null : { ...rule.style, background }
+        }
+        case "customFormula":
+            return formulaTruth(rule, condition, cell, adapter, memo) ? rule.style : null
+        default:
+            // 語彙外の type は規則ごとスキップ (fail-soft)
+            return null
+    }
+}
+
+/**
+ * Applies a CF style over a base format — the style is a partial override (`mergeFormat`
+ * semantics: a set key replaces, an unset key keeps the base), the result is canonical, `base`
+ * BY IDENTITY when nothing changes, undefined when nothing survives.
+ * CF style を base 書式へ上書き合成 — style は部分上書き (mergeFormat 意味論: 設定キーは置換、
+ * 未設定キーは base 保持)、結果は正準、無変化なら `base` を identity で、何も残らなければ undefined。
+ */
+export const applyCfStyle = (base: CellFormat | undefined, style: ConditionalFormatStyle): CellFormat | undefined => mergeFormat(base, style)
+
+/** Typed single-key write on a style (a union-typed key cannot be assigned directly under strict mode). / style への型付き単一キー書込 (union 型のキーは strict では直接代入できない)。 */
+const setStyleKey = <K extends keyof ConditionalFormatStyle>(target: ConditionalFormatStyle, key: K, value: ConditionalFormatStyle[K]): void => {
+    target[key] = value
+}
+
+/**
+ * Earlier-wins overlay: fills into `acc` only the keys it does not set yet, copying on the first
+ * fill; returns `acc` ITSELF when `style` adds nothing (identity stays meaningful).
+ * 先勝ち合成: acc が未設定のキーだけを補い、初回の補填で複製する。style が何も足さなければ
+ * `acc` そのものを返す (identity が意味を保つ)。
+ */
+const overlayUnder = (acc: ConditionalFormatStyle, style: ConditionalFormatStyle): ConditionalFormatStyle => {
+    let out = acc
+    for (const key of STYLE_KEYS) {
+        if (acc[key] === undefined && style[key] !== undefined) {
+            // 先勝ち: 先行規則が未設定のキーだけ後方規則から補う (初回の補填で初めて複製)
+            if (out === acc) {
+                out = { ...acc }
+            }
+            setStyleKey(out, key, style[key])
+        }
+    }
+    return out
+}
+
+/** Intern key of an accumulated style: undefined / false / "" stay distinct (undefined keeps the base, false clears, "" is an empty colour text). / 累積 style の intern キー: undefined / false / "" を区別 (undefined は base 保持、false は消去、"" は空の色文字列)。 */
+const styleKey = (style: ConditionalFormatStyle): string => {
+    let key = ""
+    for (const k of STYLE_KEYS) {
+        const value = style[k]
+        key += value === undefined ? "" : typeof value === "boolean" ? (value ? "t" : "f") : `s${value.length}:${value}`
+        key += "\u0000"
+    }
+    return key
+}
+
+/** Per-base intern store: by style identity (one identity-stable contribution) and by accumulated-style key (bounded). / base 毎の intern 保管: style identity (単一の identity 安定寄与) とキー (有界)。 */
+type PaintedStore = { readonly byStyle: WeakMap<ConditionalFormatStyle, CellFormat>; readonly byKey: Map<string, CellFormat> }
+
+/** Module-level intern keyed by the base format OBJECT (undefined base ⇒ the NO_BASE sentinel), surviving index rebuilds. / base 書式 object をキーにするモジュール水準の intern (undefined base は NO_BASE 番兵)。索引再構築を跨いで生きる。 */
+const paintedStores = new WeakMap<CellFormat, PaintedStore>()
+
+/** Sentinel key for an undefined base. / undefined base の番兵キー。 */
+const NO_BASE: CellFormat = Object.freeze({})
+
+/** The intern store of a base (created on first use). / base の intern 保管 (初回利用で生成)。 */
+const storeFor = (base: CellFormat | undefined): PaintedStore => {
+    const key = base === undefined ? NO_BASE : base
+    const hit = paintedStores.get(key)
+    if (hit !== undefined) {
+        return hit
+    }
+    const store: PaintedStore = { byStyle: new WeakMap(), byKey: new Map() }
+    paintedStores.set(key, store)
+    return store
+}
+
+/** Interned `applyCfStyle(base, style)`: by style identity when the contribution is identity-stable, else by the accumulated style's key; an undefined result is not stored (recomputing it is free). / intern 済み applyCfStyle(base, style): identity 安定なら style identity、他は累積 style のキー。undefined の結果は格納しない (再計算は無料)。 */
+const internPainted = (base: CellFormat | undefined, style: ConditionalFormatStyle, identityStable: boolean): CellFormat | undefined => {
+    const store = storeFor(base)
+    if (identityStable) {
+        const hit = store.byStyle.get(style)
+        if (hit !== undefined) {
+            return hit
+        }
+        const painted = applyCfStyle(base, style)
+        if (painted !== undefined) {
+            store.byStyle.set(style, painted)
+        }
+        return painted
+    }
+    const key = styleKey(style)
+    const hit = store.byKey.get(key)
+    if (hit !== undefined) {
+        return hit
+    }
+    const painted = applyCfStyle(base, style)
+    if (painted !== undefined) {
+        memoSet(store.byKey, key, painted)
+    }
+    return painted
+}
+
+/**
+ * The ONE painted-format seam — base ⊕ CF (paint / autofit / editor / announcements / caret
+ * gate / getPaintedFormat). `getCellFormat` undeclared ⇒ undefined without touching the index
+ * (the v0.7 identity); `cfIndex` null or an empty column slice ⇒ the base BY IDENTITY; otherwise
+ * the cell's column slice is walked in global order (containment first, every true rule
+ * contributes, earlier wins per property, `stopIfTrue` ends the walk) and the merged format is
+ * interned per base so an unchanged answer is the identical object. `readText` is the caller's once-only
+ * thunk (`lazyCellText`) and is called only by conditions that need the text.
+ * 唯一の塗り書式合流点 — base ⊕ CF (paint / autofit / エディタ / 読み上げ / キャレットゲート /
+ * getPaintedFormat)。getCellFormat 未宣言は索引に触れず undefined (v0.7 恒等)、cfIndex null か
+ * 空の列スライスは base を identity で、他はセルの列スライスを大域順に歩き (containment を先に、
+ * 真の規則は全て寄与、同一プロパティは先勝ち、stopIfTrue で打ち切り) 合成書式を base 毎に intern する
+ * ため同じ答えは同一 object。readText は呼び手の遅延 1 回読み thunk (lazyCellText) で、text を
+ * 要する条件だけが呼ぶ。
+ */
+export const resolvePaintedFormat = (adapter: ConditionalFormatAdapter, cfIndex: CfIndex | null, memo: CfMemo, row: number, col: number, readText: () => string): CellFormat | undefined => {
+    // 能力分岐: getCellFormat 未宣言なら書式そのものが無い (v0.7 恒等 — CF は書式能力なしには存在しない)
+    if (adapter.getCellFormat === undefined) {
+        return undefined
+    }
+    const base = adapter.getCellFormat(row, col)
+    if (cfIndex === null) {
+        return base
+    }
+    const slice = columnSliceFor(cfIndex, row, col)
+    if (slice.length === 0) {
+        return base
+    }
+    const cell: CellCoord = { row, col }
+    let acc: ConditionalFormatStyle | null = null
+    let identityStable = true
+    for (const rule of slice) {
+        // containment を評価より先に (行帯内の行はスライスが保証しない) — セル外の規則は何も読まない
+        if (!containsCell(rule.ranges, cell)) {
+            continue
+        }
+        const style = evaluateCondition(rule, cell, readText, adapter, memo)
+        if (style === null) {
+            continue
+        }
+        // colorScale の寄与はセル毎の新規 object — identity intern の対象にしない
+        if (style !== rule.style) {
+            identityStable = false
+        }
+        if (acc === null) {
+            acc = style
+        } else {
+            const next = overlayUnder(acc, style)
+            // 後方規則が何かを足したときだけ累積は新規 object になる
+            if (next !== acc) {
+                identityStable = false
+                acc = next
+            }
+        }
+        if (rule.stopIfTrue === true) {
+            break
+        }
+    }
+    // 真の規則が無ければ base を identity で (無変化セルの paint intern が当たる)
+    if (acc === null) {
+        return base
+    }
+    return internPainted(base, acc, identityStable)
+}
+
+/** Memo of the autofit pre-filter by rules-array identity. / autofit 事前抽出の配列 identity memo。 */
+const widthRelevantMemo = new WeakMap<readonly ConditionalFormatRule[], readonly ConditionalFormatRule[]>()
+
+/**
+ * Autofit pre-filter: the rules whose style sets `bold` or `italic` (either value — clearing a
+ * bold base changes glyph widths too) PLUS every rule with `stopIfTrue` (it sets no width
+ * property but ends the painted walk, so keeping it makes the sliced walk stop where paint
+ * stops — a dropped rule can neither own bold / italic nor terminate, hence exact parity), in
+ * global order; the input array ITSELF when every rule is relevant; memoised by array identity.
+ * autofit 事前抽出: style が bold か italic を設定する規則 (値は問わない — bold base の解除も
+ * 字幅を変える) と stopIfTrue の規則 (幅には効かないが塗りの walk を止める障壁 — 残すことで
+ * スライス済み walk も塗りと同じ位置で止まる。落とした規則は bold / italic を持たず walk も
+ * 止めないため結果は厳密一致) を大域順で。全件該当なら入力配列そのもの。配列 identity で memo。
+ */
+export const widthRelevantRules = (rules: readonly ConditionalFormatRule[]): readonly ConditionalFormatRule[] => {
+    assertRules(rules, "widthRelevantRules")
+    const hit = widthRelevantMemo.get(rules)
+    if (hit !== undefined) {
+        return hit
+    }
+    // 幅に効く規則 (bold / italic) に加え stopIfTrue の障壁も残す — 塗りと同じ位置で walk を止めるため
+    const relevant = rules.filter((rule) => rule.style.bold !== undefined || rule.style.italic !== undefined || rule.stopIfTrue === true)
+    // 全件該当なら入力そのもの (呼び手の identity 比較が意味を持つ)
+    const result = relevant.length === rules.length ? rules : relevant
+    widthRelevantMemo.set(rules, result)
+    return result
+}