@aiquants/virtualscroll 1.18.5 → 1.19.0

package/src/useFenwickMapTree.spec.ts

@@ -0,0 +1,1518 @@
+/**
+ * @file Tests for FenwickMapTree and useFenwickMapTree.
+ * @file FenwickMapTree と useFenwickMapTree のテスト。
+ */
+import { act, renderHook } from "@testing-library/react"
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"
+import { FenwickMapTree, useFenwickMapTree } from "./useFenwickMapTree.ts"
+
+let warnSpy: ReturnType<typeof vi.spyOn> | undefined
+
+beforeAll(() => {
+    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+})
+
+afterAll(() => {
+    warnSpy?.mockRestore()
+    warnSpy = undefined
+})
+
+describe("FenwickMapTree", () => {
+    describe("コンストラクタと初期化", () => {
+        it("固定値で正しく初期化されるべき", () => {
+            const tree = new FenwickMapTree(10, 20)
+            expect(tree.getSize()).toBe(10)
+            expect(tree.get(0)).toBe(20)
+            expect(tree.get(9)).toBe(20)
+            expect(tree.prefixSum(0).cumulative).toBe(20)
+            expect(tree.prefixSum(4).cumulative).toBe(100)
+            expect(tree.getTotal()).toBe(200)
+        })
+
+        it("関数で正しく初期化されるべき", () => {
+            const valueFn = (index: number) => (index + 1) * 10
+            const tree = new FenwickMapTree(10, valueFn)
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(55 * 10) // 中央値の 55 * 10 になる。
+            expect(tree.prefixSum(5).total).toBe(55 * 10) // prefixSum は materialize しない
+            // get は materialize しない。中央値の 55 になる。
+            expect(tree.get(5)).toBe(55)
+            // prefixSum は materialize しない
+            expect(tree.prefixSum(2).cumulative).toBe(55 + 55 + 55)
+            // 具現化して値を確認
+            expect(tree.get(5, { materializeOption: { materialize: true } })).toBe(60) // 6 * 10
+            expect(tree.getTotal()).toBe(550 + 5)
+            // 具現化して接頭辞和を確認
+            expect(tree.prefixSum(4, { materializeOption: { materialize: true } }).cumulative).toBe(55 + 55 + 55 + 55 + 50)
+            expect(tree.prefixSum(4, { materializeOption: { materialize: true } }).total).toBe(55 + 55 + 55 + 55 + 50 + 60 + 55 + 55 + 55 + 55) // 具現化後の合計値も確認
+            // 具現化して接頭辞和を確認
+            expect(tree.prefixSum(5, { materializeOption: { materialize: true } }).cumulative).toBe(55 + 55 + 55 + 55 + 50 + 60)
+            expect(tree.prefixSum(5, { materializeOption: { materialize: true } }).total).toBe(55 + 55 + 55 + 55 + 50 + 60 + 55 + 55 + 55 + 55) // 具現化後の合計値も確認
+            // 具現化して接頭辞和を確認
+            expect(tree.prefixSum(7, { materializeOption: { materialize: true } }).cumulative).toBe(55 + 55 + 55 + 55 + 50 + 60 + 55 + 80)
+            // 具現化後の合計値も確認
+            expect(tree.getTotal()).toBe(55 + 55 + 55 + 55 + 50 + 60 + 55 + 80 + 55 + 55)
+            // 具現化後の接頭辞和も確認
+            expect(
+                tree.prefixSum(9, {
+                    materializeOption: {
+                        materialize: true,
+                        ranges: [
+                            { from: 0, to: 1 },
+                            { from: 2, to: 2 },
+                        ],
+                    },
+                }).cumulative,
+            ).toBe(10 + 20 + 30 + 55 + 50 + 60 + 55 + 80 + 55 + 100)
+        })
+
+        it("関数とサンプリングオプションで初期化されるべき - サンプリング範囲が全体と一致", () => {
+            const valueFn = (i: number) => (i < 5 ? 10 : 20)
+            const tree = new FenwickMapTree(10, valueFn, { sampleRange: { from: 0, to: 9 } })
+            // サンプリング範囲の値は [10, 10, 10, 10, 10, 20, 20, 20, 20, 20]
+            // 合計は 150, 中央値は 15。baseValue は 15 になる。
+            // get は具現化しない限り baseValue を返す
+            expect(tree.get(0)).toBe(15)
+            expect(tree.get(4)).toBe(15)
+            expect(tree.get(5)).toBe(15)
+            expect(tree.get(9)).toBe(15)
+            // 具現化すると valueFn の値が返る
+            expect(tree.get(0, { materializeOption: { materialize: true } })).toBe(10)
+            expect(tree.get(9, { materializeOption: { materialize: true } })).toBe(20)
+            // getTotal は valueFn を全範囲で評価した合計値
+            expect(tree.getTotal()).toBe(150)
+        })
+
+        it("関数とサンプリングオプションで初期化されるべき - サンプリング範囲が一部", () => {
+            const valueFn = (i: number) => (i < 5 ? 10 : 100) // 0-4: 10, 5-9: 100
+            // 最初の5要素のみサンプリング
+            const tree = new FenwickMapTree(10, valueFn, { sampleRange: { from: 0, to: 4 } })
+            // サンプリング範囲の値は [10, 10, 10, 10, 10]
+            // baseValue は 10 になる。
+            expect(tree.get(0)).toBe(10) // サンプリング範囲内 (baseValue)
+            expect(tree.get(9)).toBe(10) // サンプリング範囲外 (baseValue)
+            // 具現化すると正しい値が返る
+            expect(tree.get(9, { materializeOption: { materialize: true } })).toBe(100)
+            // getTotal は valueFn を全範囲で評価した合計値
+            expect(tree.getTotal()).toBe(5 * 10 + 4 * 10 + 100)
+        })
+
+        it("関数とサンプリングオプションで初期化されるべき - サンプリングで baseValue が偏る場合", () => {
+            const valueFn = (i: number) => (i === 0 ? 100 : 10) // ほとんどが10
+            // 全範囲をサンプリングすると、最頻値は 10 になるため baseValue は 10 になる
+            const tree = new FenwickMapTree(10, valueFn, { sampleRange: { from: 0, to: 9 } })
+            // get は具現化しない限り baseValue を返す
+            expect(tree.get(5)).toBe(10)
+            // 具現化
+            expect(tree.get(0, { materializeOption: { materialize: true } })).toBe(100)
+            expect(tree.get(1, { materializeOption: { materialize: true } })).toBe(10)
+            // 合計値は valueFn を全範囲で評価した合計値になる
+            const expectedTotal = 100 + 9 * 10
+            expect(tree.getTotal({ materializeOption: { materialize: true } })).toBe(expectedTotal)
+        })
+
+        it("関数とサンプリングオプションで初期化されるべき - サンプリングサイズが小さい - 初期具現化なし", () => {
+            const valueFn = (i: number) => 100 + i
+            // 2要素だけサンプリング。サンプリング範囲はデフォルトで具現化されない
+            const tree = new FenwickMapTree(20, valueFn, { sampleRange: { from: 5, to: 6 } })
+            // サンプル値: 105, 106。 baseValue = Math.floor((105+106)/2) = 105
+            expect(tree.get(0)).toBe(105)
+            // 具現化
+            expect(tree.get(0, { materializeOption: { materialize: true } })).toBe(100)
+            // 合計値
+            // baseValue が 105 になるため、具現化されていない 19 個の要素は 105 として扱われる。
+            // 具現化済みの1要素 (index:0) と合わせて、合計は 19 * 105 + 100 = 2095 となる。
+            const expectedTotal = 19 * 105 + 100
+            expect(tree.getTotal()).toBe(expectedTotal) // 2095
+        })
+
+        it("関数とサンプリングオプションで初期化されるべき - サンプリングサイズが小さい - 初期具現化あり", () => {
+            const valueFn = (i: number) => 100 + i
+            // 2要素だけサンプリング。サンプリング範囲はデフォルトで具現化されない
+            const tree = new FenwickMapTree(20, valueFn, { sampleRange: { from: 5, to: 6 }, materialize: true })
+            // サンプル値: 105, 106。 baseValue = Math.floor((105+106)/2) = 105
+            expect(tree.get(0)).toBe(105)
+            // 具現化
+            expect(tree.get(0, { materializeOption: { materialize: true } })).toBe(100)
+            // 合計値
+            // baseValue が 105 になるため、具現化されていない 17 個の要素は 105 として扱われる。
+            // 具現化済みの3要素 (5, 6, 0) と合わせて、合計は 17 * 105 + 105 + 106 + 100 = 2096 となる。
+            const expectedTotal = 17 * 105 + 105 + 106 + 100
+            expect(tree.getTotal()).toBe(expectedTotal) // 2096
+        })
+
+        it("サイズ 0 で正しく初期化されるべき", () => {
+            const tree = new FenwickMapTree(0, 10)
+            expect(tree.getSize()).toBe(0)
+            expect(tree.getTotal()).toBe(0)
+            expect(tree.prefixSum(-1).cumulative).toBe(0)
+            expect(tree.findIndexAtOrAfter(10).index).toBe(-1)
+        })
+    })
+
+    describe("update と updates", () => {
+        it("単一の値を正しく更新するべき", () => {
+            const tree = new FenwickMapTree(10, 10) // total = 100
+            tree.update(5, 20) // change = +10
+            expect(tree.get(5)).toBe(20)
+            expect(tree.getTotal()).toBe(110)
+            expect(tree.prefixSum(5).cumulative).toBe(5 * 10 + 20)
+        })
+
+        it("複数の値を正しく更新するべき", () => {
+            const tree = new FenwickMapTree(10, 10) // total = 100
+            tree.updates([
+                { index: 2, value: 5 }, // change = -5
+                { index: 8, value: 15 }, // change = +5
+            ])
+            expect(tree.get(2)).toBe(5)
+            expect(tree.get(8)).toBe(15)
+            expect(tree.getTotal()).toBe(100)
+            expect(tree.prefixSum(8).cumulative).toBe(7 * 10 + 5 + 15)
+        })
+
+        it("関数で初期化されたツリーを正しく更新するべき", () => {
+            const tree = new FenwickMapTree(10, (i) => i) // baseValue は 4, total は 40
+            tree.update(5, 10) // 元の値は baseValue(4), change = +6
+            expect(tree.get(5)).toBe(10)
+            expect(tree.getTotal()).toBe(46) // 40 + 6
+        })
+    })
+
+    describe("prefixSum", () => {
+        it("接頭辞和を正しく計算するべき", () => {
+            const tree = new FenwickMapTree(10, (i) => i + 1) // 1, 2, ..., 10
+            expect(tree.prefixSum(2).cumulative).toBe(5 + 5 + 5)
+            expect(tree.prefixSum(9).cumulative).toBe(5 * 10)
+        })
+
+        it("更新後の接頭辞和を正しく計算するべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            tree.update(5, 0)
+            expect(tree.prefixSum(4).cumulative).toBe(50)
+            expect(tree.prefixSum(5).cumulative).toBe(50)
+            expect(tree.prefixSum(6).cumulative).toBe(60)
+        })
+
+        it("範囲外のインデックスは正しく処理されるべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            expect(tree.prefixSum(-1).cumulative).toBe(0)
+            expect(tree.prefixSum(10).cumulative).toBe(100) // size-1 に丸められる
+        })
+
+        it("materialize オプションが正しく動作するべき", () => {
+            const valueFn = vi.fn((index: number) => index * 10)
+            const tree = new FenwickMapTree(10, valueFn)
+
+            // 具現化なし
+            tree.prefixSum(5)
+            expect(valueFn).toHaveBeenCalledTimes(10)
+
+            // 具現化あり
+            tree.prefixSum(5, { materializeOption: { materialize: true } })
+            // 5 のみ具現化される
+            expect(valueFn).toHaveBeenCalledTimes(11)
+        })
+    })
+
+    describe("getTotal", () => {
+        it("初期状態の合計値を正しく計算するべき", () => {
+            const tree = new FenwickMapTree(10, 15)
+            expect(tree.getTotal()).toBe(150)
+        })
+
+        it("関数で初期化されたツリーの合計値を正しく計算するべき", () => {
+            const tree = new FenwickMapTree(10, (i) => i)
+            expect(tree.getTotal()).toBe(4 * 10)
+        })
+
+        it("更新後の合計値を正しく計算するべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            tree.update(0, 20)
+            tree.update(9, 0)
+            expect(tree.getTotal()).toBe(100)
+        })
+    })
+
+    describe("changeSize", () => {
+        it("サイズを大きくするべき", () => {
+            const tree = new FenwickMapTree(5, 10) // total = 50
+            tree.changeSize(10)
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(100)
+            expect(tree.get(9)).toBe(10)
+        })
+
+        it("サイズを小さくするべき", () => {
+            const tree = new FenwickMapTree(10, 10) // total = 100
+            tree.update(8, 20) // total = 110
+            tree.changeSize(5)
+            expect(tree.getSize()).toBe(5)
+            // サイズ縮小により、[0, 4] の範囲の要素のみが残る。
+            // インデックス 8 の更新は失われるため、合計値は 5 * 10 = 50 になる。
+            expect(tree.getTotal()).toBe(50)
+            expect(() => tree.get(8)).toThrow()
+        })
+
+        it("関数で初期化されたツリーのサイズを小さくするべき", () => {
+            // valueFn で初期化。サンプル範囲は [0, 4]。値は [0, 1, 2, 3, 4]。
+            // 平均は 2 なので baseValue は 2。初期 total は 2 * 5 = 10。
+            const tree = new FenwickMapTree(5, (i) => i)
+            expect(tree.getTotal()).toBe(10)
+
+            // インデックス 4 の値を 10 に更新。元の値は baseValue(2) なので、差分は +8。
+            // total は 10 + 8 = 18 になる。
+            tree.update(4, 10)
+            expect(tree.getTotal()).toBe(18)
+
+            // サイズを 3 に縮小。インデックス 4 の更新は失われる。
+            // 新しいツリーは size=3, baseValue=2 で再計算される。
+            // total は 2 * 3 = 6 になる。
+            tree.changeSize(3)
+            expect(tree.getSize()).toBe(3)
+            expect(tree.getTotal()).toBe(6)
+            // 縮小後の範囲の値を具現化して確認
+            expect(tree.get(0, { materializeOption: { materialize: true } })).toBe(0)
+            expect(tree.get(1, { materializeOption: { materialize: true } })).toBe(1)
+            expect(tree.get(2, { materializeOption: { materialize: true } })).toBe(2)
+            // 具現化後の合計値は 0 + 1 + 2 = 3
+            expect(tree.getTotal()).toBe(3)
+        })
+
+        it("関数で初期化されたツリーのサイズを大きくするべき", () => {
+            // valueFn で初期化。baseValue は 2。total は 2 * 5 = 10。
+            const tree = new FenwickMapTree(5, (i) => i)
+            tree.update(2, 10) // 元の値は baseValue(2)。差分 +8。total = 18。
+            expect(tree.getTotal()).toBe(18)
+
+            // サイズを 8 に拡大。
+            // 既存の要素 [0-4] は維持され、新しい要素 [5-7] が baseValue(2) で追加される。
+            // total は 18 + 3 * 2 = 24 になる。
+            tree.changeSize(8)
+            expect(tree.getSize()).toBe(8)
+            expect(tree.getTotal()).toBe(24)
+            // 維持された更新済みの値を確認
+            expect(tree.get(2)).toBe(10)
+            // 新しく追加された値を確認
+            expect(tree.get(7)).toBe(2)
+            // 新しい要素を具現化
+            expect(tree.get(7, { materializeOption: { materialize: true } })).toBe(7)
+            // 具現化による差分 (7 - 2 = 5) が total に反映される。
+            expect(tree.getTotal()).toBe(24 + 5)
+        })
+
+        it("サイズ 0 に変更してから再度大きくするべき", () => {
+            const tree = new FenwickMapTree(5, 10)
+            tree.update(3, 20) // total = 60
+            tree.changeSize(0)
+            expect(tree.getSize()).toBe(0)
+            expect(tree.getTotal()).toBe(0)
+
+            tree.changeSize(3)
+            expect(tree.getSize()).toBe(3)
+            // 新しい要素は baseValue(10) で初期化される
+            expect(tree.getTotal()).toBe(30)
+            expect(tree.get(0)).toBe(10)
+        })
+
+        it("サイズを拡大・縮小を繰り返すべき", () => {
+            const tree = new FenwickMapTree(5, 10) // size: 5, total: 50
+            tree.update(1, 20) // total: 60
+
+            // 1. 拡大
+            tree.changeSize(10) // size: 10, total: 60 + 5*10 = 110
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(110)
+            tree.update(8, 30) // total: 110 - 10 + 30 = 130
+            expect(tree.getTotal()).toBe(130)
+
+            // 2. 縮小
+            tree.changeSize(7) // size: 7
+            // インデックス 8 の更新は失われる。
+            // total はインデックス 1 の更新 (20) + 6 * 10 = 80
+            expect(tree.getSize()).toBe(7)
+            expect(tree.getTotal()).toBe(80)
+            expect(() => tree.get(8)).toThrow()
+            expect(tree.get(1)).toBe(20)
+
+            // 3. 再度拡大
+            tree.changeSize(12) // size: 12
+            // total は 80 + 5 * 10 = 130
+            expect(tree.getSize()).toBe(12)
+            expect(tree.getTotal()).toBe(130)
+            expect(tree.get(11)).toBe(10)
+        })
+
+        it("関数で初期化されたツリーでサイズを拡大・縮小を繰り返すべき", () => {
+            const valueFn = (i: number) => 100 + i
+            const tree = new FenwickMapTree(10, valueFn) // baseValue: 104
+            // total: 104 * 10 = 1040
+
+            // 1. 拡大
+            tree.changeSize(15) // total: 1040 + 5 * 104 = 1560
+            expect(tree.getSize()).toBe(15)
+            expect(tree.getTotal()).toBe(1560)
+
+            // 2. 具現化と更新
+            expect(tree.get(12, { materializeOption: { materialize: true } })).toBe(112)
+            // total: 1560 - 104 + 112 = 1568
+            expect(tree.getTotal()).toBe(1568)
+            tree.update(5, 200) // 元の値は baseValue(104), 差分 +96
+            // total: 1568 + 96 = 1664
+            expect(tree.getTotal()).toBe(1664)
+
+            // 3. 縮小
+            tree.changeSize(8)
+            // インデックス 12 の具現化と更新は失われる。
+            // インデックス 5 の更新は残る。
+            // 新しい total は、baseValue(104) * 7 + 更新された値(200) = 728 + 200 = 928
+            expect(tree.getSize()).toBe(8)
+            expect(tree.getTotal()).toBe(928)
+
+            // 4. 再度拡大
+            tree.changeSize(10)
+            // total: 928 + 2 * 104 = 1136
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(1136)
+            // 失われたインデックス 8 の値は baseValue に戻る
+            expect(tree.get(8)).toBe(104)
+        })
+    })
+
+    describe("findIndexAtOrAfter", () => {
+        const tree = new FenwickMapTree(10, 10) // 各要素10, 累積和は 10, 20, ..., 100
+        tree.update(5, 20) // 累積和は ..., 50, 70, 80, ...
+
+        it("findIndexAtOrAfter が正しいインデックスを見つけるべき", () => {
+            expect(tree.findIndexAtOrAfter(25).index).toBe(2)
+            expect(tree.findIndexAtOrAfter(30).index).toBe(2)
+            expect(tree.findIndexAtOrAfter(70).index).toBe(5)
+            expect(tree.findIndexAtOrAfter(1).index).toBe(0)
+            expect(tree.findIndexAtOrAfter(121).index).toBe(-1)
+        })
+
+        it("findIndexAtOrAfter の境界値テスト（findLast相当の検証）", () => {
+            // findLast(25) は index 1 を返すべきだったが、findIndexAtOrAfter では境界値を確認
+            // 累積和: [10, 20, 30, 40, 50, 70, 80, 90, 100, 110]
+
+            // 25 以上の最初のインデックスは 2 (累積和30)
+            expect(tree.findIndexAtOrAfter(25).index).toBe(2)
+            // 24 以上の最初のインデックスは 2 (累積和30)
+            expect(tree.findIndexAtOrAfter(24).index).toBe(2)
+            // 20 以上の最初のインデックスは 1 (累積和20)
+            expect(tree.findIndexAtOrAfter(20).index).toBe(1)
+            // 21 以上の最初のインデックスは 2 (累積和30)
+            expect(tree.findIndexAtOrAfter(21).index).toBe(2)
+        })
+
+        it("findIndexAtOrAfter の境界値テスト（より多くのパターン）", () => {
+            // 元の findLast のテストパターンを findIndexAtOrAfter で検証
+            // findLast(69) は index 4 を返すべきだった -> 69以上は index 5
+            expect(tree.findIndexAtOrAfter(69).index).toBe(5)
+            expect(tree.findIndexAtOrAfter(70).index).toBe(5)
+            expect(tree.findIndexAtOrAfter(71).index).toBe(6)
+
+            // findLast(1) は index -1 を返すべきだった -> 1以上は index 0
+            expect(tree.findIndexAtOrAfter(1).index).toBe(0)
+            expect(tree.findIndexAtOrAfter(0).index).toBe(0)
+
+            // findLast(121) は index 9 を返すべきだった -> 121以上は存在しない
+            expect(tree.findIndexAtOrAfter(121).index).toBe(-1)
+            expect(tree.findIndexAtOrAfter(110).index).toBe(9)
+            expect(tree.findIndexAtOrAfter(111).index).toBe(-1)
+        })
+
+        it("findIndexAtOrAfter を total 値で呼び出すと末尾のインデックスを返すこと", () => {
+            const total = tree.getTotal()
+            const result = tree.findIndexAtOrAfter(total)
+            expect(result.index).toBe(tree.getSize() - 1)
+            const offset = total - tree.prefixSum(result.index - 1).cumulative
+            expect(offset).toBe(tree.get(result.index))
+        })
+    })
+
+    describe("エッジケース", () => {
+        it("範囲外のインデックスで get を呼ぶとエラーをスローするべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            expect(() => tree.get(10)).toThrow("Index out of bounds")
+            expect(() => tree.get(-1)).toThrow("Index out of bounds")
+        })
+
+        it("範囲外のインデックスで update を呼ぶとエラーをスローするべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            // updateDeltas 内でエラーがスローされる
+            expect(() => tree.update(10, 10)).toThrow("Index 10 out of bounds")
+        })
+
+        it("負の値を update しようとするとエラーをスローするべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            expect(() => tree.update(5, -10)).toThrow("Value cannot be negative.")
+        })
+    })
+
+    describe("複雑なシナリオと連続操作", () => {
+        it("更新、サイズ拡大、再更新後に正しい状態を保つべき", () => {
+            const tree = new FenwickMapTree(5, 10) // size: 5, total: 50
+            tree.update(2, 20) // [10, 10, 20, 10, 10], total: 60
+            expect(tree.getTotal()).toBe(60)
+
+            tree.changeSize(8) // size: 8, [10, 10, 20, 10, 10, 10, 10, 10]
+            expect(tree.getSize()).toBe(8)
+            expect(tree.getTotal()).toBe(90) // [10, 10, 20, 10, 10, 10, 10, 10]
+
+            tree.update(7, 30) // [10, 10, 20, 10, 10, 10, 10, 30], total: 110
+            expect(tree.get(7)).toBe(30)
+            expect(tree.getTotal()).toBe(110)
+            expect(tree.prefixSum(7).cumulative).toBe(110)
+            expect(tree.prefixSum(3).cumulative).toBe(50)
+        })
+
+        it("更新、サイズ縮小、再更新後に正しい状態を保つべき", () => {
+            const tree = new FenwickMapTree(10, (i) => i) // 0..9, total: 40, baseValue: 4
+            tree.updates([
+                { index: 8, value: 20 }, // 元の値は baseValue(4), 差分 +16
+                { index: 9, value: 30 }, // 元の値は baseValue(4), 差分 +26
+            ]) // total: 40 + 16 + 26 = 82
+            tree.changeSize(5) // 4,4,4,4,5, total: 20
+            expect(tree.getTotal()).toBe(20)
+
+            // サイズ縮小: size=5
+            // baseValue は 4 のまま。インデックス 8, 9 の更新は破棄される。
+            // 新しい total は 4 * 5 = 20
+            tree.changeSize(5)
+            expect(tree.getSize()).toBe(5)
+            expect(tree.getTotal()).toBe(20)
+            // 累積和の確認: [4, 4, 4, 4, 4] -> 合計 20
+            expect(tree.prefixSum(4).cumulative).toBe(20)
+
+            // 再更新: index=0 の値を 10 に
+            // 元の値は baseValue(4), 差分 +6
+            // 新しい total は 20 + 6 = 26
+            tree.update(0, 10)
+            expect(tree.getTotal()).toBe(26)
+            // 累積和の確認: [10, 4, 4, 4, 4] -> 合計 26
+            expect(tree.prefixSum(4).cumulative).toBe(26)
+        })
+
+        it("find, updateDelta, resize, getTotal, reset の連続操作が正しく動作するべき", () => {
+            const valueFn = vi.fn((i: number) => 10 + i) // 10, 11, 12, ...
+            // サンプル値は [10...19]、中央値は (14+15)/2=14.5 -> baseValue=14
+            const tree = new FenwickMapTree(10, valueFn)
+            let total = 14 * 10 // 140
+            expect(tree.getTotal()).toBe(total)
+
+            // 1. 一部を具現化
+            // コンストラクタで10回、prefixSumで1回呼ばれる
+            expect(tree.prefixSum(3, { materializeOption: { materialize: true } }).cumulative).toBe(14 + 14 + 14 + 13) // 3 のみ具現化
+            expect(valueFn).toHaveBeenCalledTimes(11)
+            total += 13 - 14 // 140 - 1 = 139
+            expect(tree.getTotal()).toBe(total)
+
+            // 2. 具現化済みと未具現化のインデックスを更新
+            tree.updates([
+                // index 2 は未具現化。元の値は baseValue(14)。差分は 5 - 14 = -9
+                { index: 2, value: 5 },
+                // index 8 は未具現化。元の値は baseValue(14)。差分は 25 - 14 = +11
+                { index: 8, value: 25 },
+            ])
+            total += 5 - 14 + (25 - 14) // 139 - 9 + 11 = 141
+            expect(tree.getTotal()).toBe(total)
+
+            // 3. サイズ変更
+            tree.changeSize(12)
+            expect(tree.getSize()).toBe(12)
+            // 新しい要素 (index 10, 11) は baseValue(14) で埋められる
+            total += 2 * 14 // 141 + 28 = 169
+            expect(tree.getTotal()).toBe(total)
+
+            // 4. 再更新
+            tree.update(11, 50) // baseValue(14) -> 50, diff: +36
+            total += 50 - 14 // 169 + 36 = 205
+            expect(tree.getTotal()).toBe(total)
+
+            // 5. サイズ縮小
+            tree.changeSize(5)
+            expect(tree.getSize()).toBe(5)
+            // 削除される範囲: [5, 11]
+            // 削除される更新: index 8 (25), index 11 (50)
+            // 残る範囲: [0, 4]
+            // 残る更新: index 2 (5)
+            // 残る具現化: index 3 (13)
+            //
+            // 再計算:
+            // index 0,1,4 は baseValue (14)
+            // index 2 は更新済み (5)
+            // index 3 は具現化済み (13)
+            // total = 14 * 3 + 5 + 13 = 42 + 18 = 60
+            expect(tree.getTotal()).toBe(60)
+        })
+
+        it("遅延初期化と複数操作を組み合わせても正しく動作するべき", () => {
+            const valueFn = vi.fn((i: number) => i * 10)
+            // 初期化: size=10, valueFn=(i)=>i*10
+            // サンプル値は [0, 10, ..., 90] で全てユニークなため、中央値が baseValue になる。
+            // baseValue = (40 + 50) / 2 = 45
+            const tree = new FenwickMapTree(10, valueFn)
+            // 初期 total は baseValue * size = 45 * 10 = 450
+            expect(tree.getTotal()).toBe(450)
+
+            // 1. 一部を具現化
+            // コンストラクタで10回、prefixSumで1回呼ばれる
+            expect(tree.prefixSum(3, { materializeOption: { materialize: true } }).cumulative).toBe(45 + 45 + 45 + 30) // 3 のみ具現化, -15
+            expect(valueFn).toHaveBeenCalledTimes(11)
+            // 具現化による差分が total に反映される
+            expect(tree.getTotal()).toBe(450 - 15)
+
+            // 2. 具現化済みと未具現化のインデックスを更新
+            tree.updates([
+                // index 2 は未具現化。元の値は baseValue(45)。差分は 25 - 45 = -20
+                { index: 2, value: 25 },
+                // index 8 は未具現化。元の値は baseValue(45)。差分は 85 - 45 = +40
+                { index: 8, value: 85 },
+            ])
+            // total = 435 - 20 + 40 = 455
+            expect(tree.getTotal()).toBe(455)
+
+            // 3. サイズ変更
+            tree.changeSize(12)
+            expect(tree.getSize()).toBe(12)
+            // 新しい要素 (index 10, 11) は baseValue(45) で埋められる
+            // total = 455 + 2 * 45 = 545
+            expect(tree.getTotal()).toBe(545)
+            expect(tree.get(11)).toBe(45) // 新しい要素は baseValue
+
+            // 4. 再更新
+            tree.update(11, 100) // baseValue(45) -> 100, diff: +55
+            // total = 545 + 55 = 600
+            expect(tree.getTotal()).toBe(600)
+
+            // 5. サイズ縮小 (更新した値が含まれるように)
+            tree.changeSize(10)
+            expect(tree.getSize()).toBe(10)
+            // 削除される範囲: [10, 11]
+            // 削除される更新: index 12 (100)
+            // 残る範囲: [0, 9]
+            // 残る具現化: index 0 (0), index 1 (1), ..., index 9 (9), total = 45
+            tree.changeSize(10)
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(455) // [45,45,25,30,45,45,45,45,85,45] = 455
+        })
+    })
+
+    describe("rebuildTree と calculateAccumulatedError", () => {
+        it("reset が valueFn でツリーを正しく再構築するべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            tree.update(5, 20)
+
+            // reset を呼び出すと、新しい size と valueFn で再初期化される
+            // サンプル値 [0,1,2,3,4] から baseValue=2 が計算される
+            tree.reset(5, (i) => i)
+
+            expect(tree.getSize()).toBe(5)
+            // baseValue は 2 なので、合計は 2 * 5 = 10
+            expect(tree.getTotal()).toBe(10)
+            // get(4) は baseValue を返す
+            expect(tree.get(4)).toBe(2)
+            // get(0) は baseValue を返す
+            expect(tree.get(0)).toBe(2)
+        })
+
+        it("calculateAccumulatedError が状態の不整合を正しく検出するべき", () => {
+            const tree = new FenwickMapTree(10, 10)
+            tree.update(5, 20)
+
+            // reset を呼び出すと、新しい size と valueFn で再初期化される
+            // サンプル値 [0,1,2,3,4] から baseValue=2 が計算され、
+            // サンプル値は即座に具現化される
+            tree.reset(5, (i) => i, { materialize: true })
+
+            expect(tree.getSize()).toBe(5)
+            // baseValue は 2 だが、全要素が具現化されているため、合計は 0+1+2+3+4=10
+            expect(tree.getTotal()).toBe(10)
+            // get(4) は具現化された値 4 を返す
+            expect(tree.get(4)).toBe(4)
+            // get(0) は具現化された値 0 を返す
+            expect(tree.get(0)).toBe(0)
+        })
+
+        it("calculateAccumulatedError が具現化による誤差を正しく計算するべき", () => {
+            // valueFn のサンプル値は [0,1,2,3,4], baseValue は 2
+            const tree = new FenwickMapTree(5, (i) => i)
+            expect(tree.getTotal()).toBe(10) // 2 * 5 = 10
+            // この時点では具現化された値はないので、誤差は 0
+            expect(tree.calculateAccumulatedError()).toBe(0)
+
+            // index 3 を具現化: valueFn(3) = 3。元の値は baseValue(2)
+            tree.get(3, { materializeOption: { materialize: true } })
+            expect(tree.getTotal()).toBe(11) // 10 + 1 = 11
+            // 実際の合計値は 2+2+2+3+2 = 11。
+            // 具現化された値の合計は 3。
+            // 未具現化の値の合計は 2 * 4 = 8。
+            // 誤差 = 0
+            expect(tree.calculateAccumulatedError()).toBe(0)
+
+            // index 0 を具現化: valueFn(0) = 0。元の値は baseValue(2)。差分は 0 - 2 = -2
+            tree.get(0, { materializeOption: { materialize: true } })
+            expect(tree.getTotal()).toBe(9) // 11 - 2 = 9
+            // 誤差 = 0
+            expect(tree.calculateAccumulatedError()).toBe(0)
+        })
+
+        it("rebuildTree 後に誤差がリセットされるべき", () => {
+            const tree = new FenwickMapTree(5, (i) => i) // baseValue=2
+            tree.get(3, { materializeOption: { materialize: true } }) // total = 11, error = 0
+            expect(tree.calculateAccumulatedError()).toBe(0)
+
+            // rebuildTree を呼び出す
+            tree.rebuildTree()
+            expect(tree.getTotal()).toBe(11) // 具現化された値は維持される
+            expect(tree.calculateAccumulatedError()).toBe(0)
+            // 以前具現化された値
+            expect(tree.get(3)).toBe(3)
+        })
+
+        it("意図的な不整合を calculateAccumulatedError が検出するべき", () => {
+            const tree = new FenwickMapTree(5, 10)
+            // 内部の total を手動で変更する
+            expect(tree.getTotal()).toBe(50)
+            // @ts-expect-error - private property access for testing
+            expect(tree.getTotal()).toBe(tree.total)
+            // 期待される誤差は 0
+            expect(tree.calculateAccumulatedError()).toBe(0)
+
+            // rebuildTree を実行
+            tree.rebuildTree()
+            expect(tree.getTotal()).toBe(50)
+            expect(tree.calculateAccumulatedError()).toBe(0)
+        })
+    })
+
+    describe("サイズ変更", () => {
+        it("updateDelta が正しく差分を更新するべき", () => {
+            const tree = new FenwickMapTree(10, 100) // total: 1000
+            // インデックス 5 の値を +20 する
+            tree.updateDelta(5, 20)
+            expect(tree.get(5)).toBe(120)
+            expect(tree.getTotal()).toBe(1020)
+            // さらに -5 する
+            tree.updateDelta(5, -5)
+            expect(tree.get(5)).toBe(115)
+            expect(tree.getTotal()).toBe(1015)
+            expect(tree.prefixSum(4).cumulative).toBe(500)
+            expect(tree.prefixSum(5).cumulative).toBe(500 + 115)
+        })
+
+        it("find, updateDelta, resize, getTotal, reset の連続操作が正しく動作するべき", () => {
+            const valueFn = vi.fn((i: number) => 10 + i) // 10, 11, 12, ...
+            // サンプル値は [10...29]、中央値は (19+20)/2=19.5 -> baseValue=19
+            const tree = new FenwickMapTree(20, valueFn)
+            const baseValue = 19
+            let total = baseValue * 20 // 380
+            expect(tree.getTotal()).toBe(total)
+
+            // 1. findIndexAtOrAfter を呼び、一部の値を具現化させる
+            // この操作により、total が変化する
+            const { index, total: newTotal } = tree.findIndexAtOrAfter(100, { materializeOption: { materialize: true } }) // 18*5=90, 19*6=114
+            expect(index).toBe(5) // index=6 が最初の具現化値, size 19 -> 15
+            expect(newTotal).toBe(376) // ?
+            total = tree.getTotal() // findIndexAtOrAfter 後の実際の total を取得
+            expect(total).toBe(newTotal)
+            const initialCalls = valueFn.mock.calls.length
+            expect(initialCalls).toBeGreaterThan(0)
+
+            // 2. 未具現化のインデックスに対して updateDelta を実行
+            // updateDelta は現在の値(未具現化なら baseValue)に差分を加える
+            // 元の値は baseValue(19), 更新後は 19 + 5 = 24
+            expect(tree.getTotal()).toBe(376)
+            tree.updateDelta(15, 5)
+            expect(tree.get(15)).toBe(24)
+            total += 5
+            expect(tree.getTotal()).toBe(total) // 368 + 5 = 373
+            // get で具現化すると、valueFn(15)=25 になる。
+            // ただし、updateDelta ですでに delta が 5 になっているので、
+            // 具現化の際に delta は valueFn(15) - baseValue = 25 - 19 = 6 に上書きされる。
+            // 最終的な total の変化は 6 - 5 = +1
+            total += 1
+            expect(tree.get(15, { materializeOption: { materialize: true } })).toBe(25)
+            expect(tree.getTotal()).toBe(total) // 373 + 1 = 374
+            expect(valueFn).toHaveBeenCalledWith(15)
+
+            // 3. サイズを縮小し、更新した要素を削除
+            tree.changeSize(10)
+            // 縮小後の合計値は、0-9 の範囲で具現化された値の合計になる
+            const materializedTotalAfterShrink = tree.getTotal({ materializeOption: { materialize: true, ranges: [{ from: 0, to: 9 }] } })
+            expect(tree.getSize()).toBe(10)
+            expect(tree.getTotal()).toBe(materializedTotalAfterShrink)
+            total = materializedTotalAfterShrink
+
+            // 4. 再びサイズを拡大
+            tree.changeSize(15)
+            expect(tree.getSize()).toBe(15)
+            // 新しい要素 (インデックス 10-14) は baseValue (19) を持つと仮定される
+            total += 5 * baseValue
+            expect(tree.getTotal()).toBe(total)
+
+            // 5. 新しく追加された範囲を具現化・更新
+            tree.get(12, { materializeOption: { materialize: true } }) // value: 10+12=22, diff: 22-19=+3
+            total += 3 // 299 + 3 = 302
+            expect(tree.getTotal()).toBe(total)
+            tree.update(13, 100) // baseValue(19) -> 100, diff: +81
+            total += 81 // 302 + 81 = 383
+            expect(tree.getTotal()).toBe(total)
+
+            // 6. サイズを縮小 (15 -> 7)
+            // 削除される範囲: [7, 14]
+            // 削除される更新: index 8 (50), index 13 (100)
+            // 削除される具現化: index 12 (34)
+            // 残る範囲: [0, 6]
+            // 残る具現化: index 0 (10), index 1 (11), index 2 (12), index 3 (13), index 4 (14), index 5 (15), index 6 (16), total = 91
+            tree.changeSize(7)
+            expect(tree.getSize()).toBe(7)
+            expect(tree.getTotal()).toBe(91)
+
+            // 7. 最終確認
+            expect(tree.get(3)).toBe(13)
+            expect(tree.get(4)).toBe(14)
+            expect(tree.get(6)).toBe(16)
+        })
+
+        it("サイズ変更を繰り返した後に findFirst が正しい値を返すか", () => {
+            // 1. 初期化
+            const tree = new FenwickMapTree(10, 10)
+            expect(tree.getTotal()).toBe(100)
+
+            // 2. 拡大と更新
+            tree.changeSize(20) // size: 20, total: 200
+            tree.update(15, 50) // total: 200 - 10 + 50 = 240
+            expect(tree.getTotal()).toBe(240)
+
+            // 3. 縮小と更新
+            tree.changeSize(10) // size: 10, total: 100 (update at 15 is lost)
+            tree.update(5, 5) // total: 100 - 10 + 5 = 95
+            expect(tree.getTotal()).toBe(95)
+
+            // 4. 再拡大
+            tree.changeSize(15) // size: 15, total: 95 + 5 * 10 = 145
+            expect(tree.getTotal()).toBe(145)
+
+            // 5. findIndexAtOrAfter の検証
+            // 累積和: [10, 20, 30, 40, 50, 55, 65, 75, 85, 95, 105, 115, 125, 135, 145]
+            // prefixSum(4) = 50
+            // prefixSum(5) = 55
+            const result1 = tree.findIndexAtOrAfter(52)
+            expect(result1.index).toBe(5)
+            const offset1 = 52 - tree.prefixSum(result1.index - 1).cumulative
+            expect(offset1).toBe(2) // 52 - 50 = 2
+            expect(result1.total).toBe(145)
+
+            const result2 = tree.findIndexAtOrAfter(55)
+            expect(result2.index).toBe(5)
+            const offset2 = 55 - tree.prefixSum(result2.index - 1).cumulative
+            expect(offset2).toBe(5) // 55 - 50 = 5
+            expect(result2.total).toBe(145)
+
+            // prefixSum(9) = 95
+            // prefixSum(10) = 105
+            const result3 = tree.findIndexAtOrAfter(100)
+            expect(result3.index).toBe(10)
+            const offset3 = 100 - tree.prefixSum(result3.index - 1).cumulative
+            expect(offset3).toBe(5) // 100 - 95 = 5
+            expect(result3.total).toBe(145)
+
+            // 範囲外
+            const result4 = tree.findIndexAtOrAfter(200)
+            expect(result4.index).toBe(-1)
+
+            // 合計値と一致
+            const total = tree.getTotal()
+            const result5 = tree.findIndexAtOrAfter(total)
+            expect(result5.index).toBe(14) // 最後のインデックス
+            const offset5 = total - tree.prefixSum(result5.index - 1).cumulative
+            expect(offset5).toBe(10) // 145 - 135 = 10
+            expect(result5.total).toBe(145)
+        })
+
+        it("巨大なサイズでサイズ変更を繰り返しても total が正確であるべき (固定値)", () => {
+            const initialSize = 100_000_000 // 1億
+            const value = 10
+            const tree = new FenwickMapTree(initialSize, value)
+
+            // 1. 初期状態の確認
+            expect(tree.getSize()).toBe(initialSize)
+            expect(tree.getTotal()).toBe(initialSize * value)
+
+            // 2. サイズを縮小
+            const smallerSize = 80_000_000 // 8千万
+            tree.changeSize(smallerSize)
+            expect(tree.getSize()).toBe(smallerSize)
+            expect(tree.getTotal()).toBe(smallerSize * value)
+
+            // 3. 値を更新
+            tree.update(100, 50) // 元の値は 10, 差分 +40
+            expect(tree.getTotal()).toBe(smallerSize * value + 40)
+
+            // 4. サイズを拡大
+            const largerSize = 120_000_000 // 1億2千万
+            tree.changeSize(largerSize)
+            expect(tree.getSize()).toBe(largerSize)
+            // 既存の合計値 + 新しく追加された要素の合計値
+            // (smallerSize * value + 40) + (largerSize - smallerSize) * value
+            // = largerSize * value + 40
+            expect(tree.getTotal()).toBe(largerSize * value + 40)
+
+            // 5. 再度サイズを縮小 (更新した値が含まれるように)
+            const finalSize = 90_000_000 // 9千万
+            tree.changeSize(finalSize)
+            expect(tree.getSize()).toBe(finalSize)
+            // 更新した値は残る
+            expect(tree.getTotal()).toBe(finalSize * value + 40)
+            expect(tree.get(100)).toBe(50)
+
+            // 6. 再度サイズを縮小 (更新した値が削除されるように)
+            const verySmallSize = 50
+            tree.changeSize(verySmallSize)
+            expect(tree.getSize()).toBe(verySmallSize)
+            // 更新した値は削除される
+            expect(tree.getTotal()).toBe(verySmallSize * value)
+            expect(() => tree.get(100)).toThrow()
+        })
+
+        it("巨大なサイズでサイズ変更を繰り返しても total が正確であるべき (関数)", () => {
+            const initialSize = 50_000_000 // 5千万
+            const valueFn = (i: number) => 10 + (i % 20) // 10から29の周期的
+            // サンプル範囲はデフォルトで [0, 999]
+            // 値は 10..29, 10..29 ...
+            // baseValue は (10+29)/2 = 19.5 -> 19
+            const tree = new FenwickMapTree(initialSize, valueFn)
+            const baseValue = 19
+
+            // 1. 初期状態の確認
+            expect(tree.getSize()).toBe(initialSize)
+            expect(tree.getTotal()).toBe(initialSize * baseValue)
+
+            // 2. サイズを縮小
+            const smallerSize = 40_000_000 // 4千万
+            tree.changeSize(smallerSize)
+            expect(tree.getSize()).toBe(smallerSize)
+            expect(tree.getTotal()).toBe(smallerSize * baseValue)
+
+            // 3. 値を更新 (未具現化)
+            const updateIndex1 = 1_000_000
+            const newValue1 = 100
+            const originalValue1 = baseValue
+            const diff1 = newValue1 - originalValue1
+            tree.update(updateIndex1, newValue1)
+            expect(tree.getTotal()).toBe(smallerSize * baseValue + diff1)
+
+            // 4. 値を具現化してから更新
+            const updateIndex2 = 2_000_000
+            const originalValue2 = valueFn(updateIndex2) // 10 + 0 = 10
+            const materializedValue2 = tree.get(updateIndex2, { materializeOption: { materialize: true } })
+            expect(materializedValue2).toBe(originalValue2)
+            const totalAfterMaterialize = smallerSize * baseValue + diff1 + (originalValue2 - baseValue)
+
+            expect(tree.getTotal()).toBe(totalAfterMaterialize)
+
+            const newValue2 = 200
+            const diff2 = newValue2 - originalValue2
+            tree.update(updateIndex2, newValue2)
+            expect(tree.getTotal()).toBe(totalAfterMaterialize + diff2)
+
+            // 5. サイズを拡大
+            const largerSize = 60_000_000 // 6千万
+            const currentTotal = tree.getTotal()
+            tree.changeSize(largerSize)
+            expect(tree.getSize()).toBe(largerSize)
+            const expectedTotalAfterLarge = currentTotal + (largerSize - smallerSize) * baseValue
+            expect(tree.getTotal()).toBe(expectedTotalAfterLarge)
+
+            // 6. 再度サイズを縮小 (更新した値が削除されるように)
+            const finalSize = 500_000
+            tree.changeSize(finalSize)
+            expect(tree.getSize()).toBe(finalSize)
+            // 更新はすべて範囲外になる
+            // total は baseValue * finalSize になるはずだが、
+            // updateIndex2 の具現化が残っている可能性がある。
+            // ここでは、具現化済みの値がリセットされないことを前提に、
+            // 縮小後の total を再計算する。
+            // updateIndex2 は削除されたので、その具現化の影響は消える。
+            // よって、baseValue * finalSize になる。
+            expect(tree.getTotal()).toBe(finalSize * baseValue)
+            expect(() => tree.get(updateIndex1)).toThrow()
+            expect(() => tree.get(updateIndex2)).toThrow()
+        })
+    })
+})
+
+describe("FenwickMapTree (回帰: 監査所見)", () => {
+    it("(c) setValueFn に数値を渡すと total が baseValue と deltas に整合する", () => {
+        const tree = new FenwickMapTree(10, 40) // total = 400
+        expect(tree.getTotal()).toBe(400)
+
+        tree.setValueFn(50, { reset: false })
+
+        // baseValue が 50 に差し替わり、deltas は空なので total は 500 になる
+        expect(tree.getTotal()).toBe(500)
+        expect(tree.prefixSum(9).cumulative).toBe(500)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(c) setValueFn 数値化後も既存 delta を保持しつつ total が整合する", () => {
+        const tree = new FenwickMapTree(4, 10) // total = 40
+        tree.update(1, 30) // delta[1] = 20, total = 60
+
+        tree.setValueFn(100, { reset: false })
+
+        // baseValue=100, delta[1]=20 -> value(1)=120, total = 100*4 + 20 = 420
+        expect(tree.get(1)).toBe(120)
+        expect(tree.getTotal()).toBe(420)
+        expect(tree.prefixSum(3).cumulative).toBe(420)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(d) updates で同一 index が重複しても差分が二重適用されない (baseValue=0)", () => {
+        const tree = new FenwickMapTree(10, 0)
+
+        tree.updates([
+            { index: 5, value: 10 },
+            { index: 5, value: 10 },
+        ])
+
+        expect(tree.get(5)).toBe(10)
+        expect(tree.getTotal()).toBe(10)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(d) updates で同一 index の異なる値は最後の値が採用される (baseValue=8)", () => {
+        const tree = new FenwickMapTree(10, 8) // total = 80
+
+        tree.updates([
+            { index: 5, value: 10 },
+            { index: 5, value: 12 },
+        ])
+
+        expect(tree.get(5)).toBe(12)
+        // 期待 total = 80 - 8 + 12 = 84
+        expect(tree.getTotal()).toBe(84)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(f) updateDeltas は範囲外 index があると先行分を適用せず throw する (アトミック)", () => {
+        const tree = new FenwickMapTree(10, 0)
+
+        expect(() =>
+            tree.updateDeltas([
+                { index: 0, change: 5 },
+                { index: 99, change: 5 },
+            ]),
+        ).toThrow()
+
+        // index 0 への +5 は適用されていないこと
+        expect(tree.get(0)).toBe(0)
+        expect(tree.getTotal()).toBe(0)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(g) 空の木 (size=0) の get / prefixSum は throw せず中立値を返す", () => {
+        const tree = new FenwickMapTree(0, 10)
+
+        expect(() => tree.get(0)).not.toThrow()
+        expect(tree.get(0)).toBe(0)
+        expect(tree.prefixSum(0).cumulative).toBe(0)
+        expect(tree.prefixSum(0).currentValue).toBe(0)
+        expect(tree.findIndexAtOrAfter(10).index).toBe(-1)
+
+        // 非空の木では範囲外 index は従来どおり throw すること
+        const nonEmpty = new FenwickMapTree(3, 10)
+        expect(() => nonEmpty.get(5)).toThrow()
+    })
+
+    it("(e) materialize ranges の from が負でも total が破損しない", () => {
+        const tree = new FenwickMapTree(10, (i) => (i === -1 ? 50 : 10), { materialize: false })
+
+        // 負の from を含む range を渡しても -1 は具現化されない
+        const prefix = tree.prefixSum(9, { materializeOption: { materialize: true, ranges: [{ from: -1, to: 3 }] } })
+
+        expect(prefix.cumulative).toBe(100)
+        expect(tree.getTotal({ materializeOption: { materialize: true, ranges: [{ from: -1, to: 3 }] } })).toBe(100)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("(L528) findIndexAtOrAfter は具現化 range 指定時に連続呼び出しでも結果が揺れない", () => {
+        const tree = new FenwickMapTree(10, (i) => (i === 0 ? 100 : 10))
+
+        const opts = { materializeOption: { materialize: true, ranges: [{ from: 0, to: 5 }] } }
+        const first = tree.findIndexAtOrAfter(15, opts)
+        const second = tree.findIndexAtOrAfter(15, opts)
+
+        // 具現化により row0=100 >= 15 なので index 0 が一貫して返る
+        expect(first.index).toBe(0)
+        expect(first.cumulative).toBe(100)
+        expect(second.index).toBe(first.index)
+        expect(second.cumulative).toBe(first.cumulative)
+    })
+
+    it("(b) 末尾伸長 (changeSize 拡大) で既存 delta が新ノードへ正しく伝播する", () => {
+        const tree = new FenwickMapTree(4, 10)
+        tree.update(0, 50) // delta[0] = 40, total = 80
+
+        tree.changeSize(8)
+
+        // index0=50, 残り 7 件は baseValue 10
+        expect(tree.get(0)).toBe(50)
+        expect(tree.get(7)).toBe(10)
+        expect(tree.getTotal()).toBe(120)
+        expect(tree.prefixSum(7).cumulative).toBe(120)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+})
+
+describe("FenwickMapTree (回帰: baseValue 分散サンプリング / 末尾追記)", () => {
+    it("先頭が非代表的な高さでも baseValue が多数派に寄り total が実測に近い", () => {
+        // 先頭 200px × 101 (ヒーロー/見出し) + 40px × 100,000 (多数派)。
+        // 旧実装 (先頭 0..99 の連続サンプリング) では全サンプルが 200 になり baseValue=200、
+        // 未具現化の全アイテムを 200px と見積もって total が実測の約 5 倍に膨らんでいた。
+        const HERO_COUNT = 101
+        const NORMAL_COUNT = 100_000
+        const size = HERO_COUNT + NORMAL_COUNT
+        const valueFn = (i: number) => (i < HERO_COUNT ? 200 : 40)
+        const tree = new FenwickMapTree(size, valueFn)
+
+        // baseValue は多数派 (40) 側に決まる。未具現化行は baseValue を返す。
+        expect(tree.get(50_000)).toBe(40)
+        // 具現化していないので total = baseValue * size = 40 * size
+        expect(tree.getTotal()).toBe(40 * size)
+
+        // 実測総高さ (200*101 + 40*100000) に対して 1% 以内。
+        const actualTotal = 200 * HERO_COUNT + 40 * NORMAL_COUNT
+        expect(Math.abs(tree.getTotal() - actualTotal) / actualTotal).toBeLessThan(0.01)
+        // 旧実装の推定 (200 * size) からは大きく離れていることも確認 (多数派が採用された証拠)。
+        expect(tree.getTotal()).toBeLessThan(200 * size * 0.5)
+    })
+
+    it("均一高さでは分散サンプリングでも baseValue が不変", () => {
+        // 一様リストは全サンプルが同一なので、しきい値超えの大サイズでも推定値は不変。
+        const size = 10_000
+        const tree = new FenwickMapTree(size, () => 33)
+        expect(tree.get(0)).toBe(33)
+        expect(tree.get(size - 1)).toBe(33)
+        expect(tree.getTotal()).toBe(33 * size)
+    })
+
+    it("周期的な高さ (20 行周期) でもストライドのエイリアシングで baseValue が偏らない", () => {
+        // stride が周期の約数だと 1 剰余類へ潰れて baseValue が偏る。奇数化により回避される。
+        const size = 50_000_000
+        const valueFn = (i: number) => 10 + (i % 20) // 10..29 の周期
+        const tree = new FenwickMapTree(size, valueFn)
+        // 全剰余をまたぐため中央値 (=19) に落ち着く。10 や 29 のような端の値には偏らない。
+        expect(tree.get(0)).toBe(19)
+        expect(tree.getTotal()).toBe(19 * size)
+    })
+
+    it("末尾追記 (changeSize 拡大) 後もオフセットと total が正確", () => {
+        const tree = new FenwickMapTree(4, 10) // 一様 10, total = 40
+        tree.update(1, 25) // delta[1] = 15, total = 55
+
+        tree.changeSize(6) // 末尾に 2 件を baseValue(10) で追記
+
+        expect(tree.getSize()).toBe(6)
+        // 既存行の対応が保たれる
+        expect(tree.get(1)).toBe(25)
+        // 追記された行は baseValue
+        expect(tree.get(4)).toBe(10)
+        expect(tree.get(5)).toBe(10)
+        // total = 55 + 2 * 10 = 75
+        expect(tree.getTotal()).toBe(75)
+        // 各インデックスまでの累積オフセットが正確
+        expect(tree.prefixSum(0).cumulative).toBe(10)
+        expect(tree.prefixSum(1).cumulative).toBe(35) // 10 + 25
+        expect(tree.prefixSum(3).cumulative).toBe(55) // 10 + 25 + 10 + 10
+        expect(tree.prefixSum(5).cumulative).toBe(75)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+})
+
+describe("FenwickMapTree (回帰: r3 監査所見)", () => {
+    it("小数 baseValue の末尾 +1 追記でも total が prefixSum と厳密一致し整合検査が誤発火しない", () => {
+        // 増分 total 更新 (+= baseValue * Δ) は浮動小数点の分配則不成立により
+        // prefixSum の走査結果と厳密不一致になり、追記のたびに偽の
+        // "Inconsistent Fenwick Tree state" エラーを出していた回帰の再現。
+        const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+        try {
+            // 7 値周期の小数高さ: 各値の頻度 20% 以下のため _modeOrMedian は生の小数中央値を
+            // baseValue に採用する (FP 乖離の再現条件)
+            const valueFn = (i: number) => 24.7 + (i % 7) * 0.13
+            const tree = new FenwickMapTree(200, valueFn)
+            for (let size = 201; size <= 260; size++) {
+                tree.changeSize(size)
+                const last = tree.prefixSum(size - 1)
+                // total キャッシュと prefixSum 走査は厳密一致すること
+                expect(last.cumulative).toBe(last.total)
+            }
+            expect(errorSpy).not.toHaveBeenCalled()
+        } finally {
+            errorSpy.mockRestore()
+        }
+    })
+
+    it("ランダム差分: update と伸長を混在させた木が reset 再構築した木と全点一致する", () => {
+        // 決定的な擬似乱数 (LCG) で再現可能にする
+        let seed = 123456789
+        const rand = () => {
+            seed = (seed * 1664525 + 1013904223) >>> 0
+            return seed / 0x100000000
+        }
+        const base = 20
+        let size = 120
+        const tree = new FenwickMapTree(size, base)
+        const expected = new Map<number, number>()
+        for (let step = 0; step < 300; step++) {
+            if (rand() < 0.5) {
+                const index = Math.floor(rand() * size)
+                const value = Math.floor(rand() * 50)
+                tree.update(index, value)
+                expected.set(index, value)
+            } else {
+                // 1〜8 件の末尾追記 (2 冪境界も自然に跨ぐ)
+                size += 1 + Math.floor(rand() * 8)
+                tree.changeSize(size)
+            }
+        }
+        // 同じ値を一括適用して再構築した木と全点一致すること
+        const rebuilt = new FenwickMapTree(size, base)
+        rebuilt.updates([...expected.entries()].map(([index, value]) => ({ index, value })))
+        let cumulative = 0
+        for (let i = 0; i < size; i++) {
+            cumulative += expected.get(i) ?? base
+            expect(tree.prefixSum(i).cumulative).toBe(cumulative)
+            expect(rebuilt.prefixSum(i).cumulative).toBe(cumulative)
+        }
+        expect(tree.getTotal()).toBe(cumulative)
+        expect(rebuilt.getTotal()).toBe(cumulative)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("2 冪境界を跨ぐ +1 伸長でも既存 delta が新規有効化ノードへ正しく伝播する", () => {
+        for (const boundary of [128, 256, 512]) {
+            const tree = new FenwickMapTree(boundary - 1, 10)
+            tree.update(0, 60) // delta +50
+            tree.update(boundary - 2, 35) // delta +25
+            tree.changeSize(boundary) // 2 冪ノード (boundary) が新規有効化される
+            tree.changeSize(boundary + 1)
+            const expectedTotal = 10 * (boundary + 1) + 50 + 25
+            expect(tree.prefixSum(boundary).cumulative).toBe(expectedTotal)
+            expect(tree.getTotal()).toBe(expectedTotal)
+            expect(tree.calculateAccumulatedError()).toBe(0)
+        }
+    })
+
+    it("小リストの reset は負の sampleRange をクランプし、負 index の valueFn 呼び出しと NaN 汚染を起こさない", () => {
+        // 配列添字ベースの valueFn (負 index では undefined を返す実運用形)
+        const heights = Array.from({ length: 50 }, () => 30)
+        const calls: number[] = []
+        const valueFn = (i: number) => {
+            calls.push(i)
+            return heights[i]
+        }
+        const tree = new FenwickMapTree(50, valueFn, { sampleRange: { from: -5, to: 10 }, materialize: true })
+        // 負 index で valueFn が呼ばれないこと
+        expect(calls.every((i) => i >= 0 && i < 50)).toBe(true)
+        // baseValue / total が NaN 汚染されないこと
+        expect(Number.isFinite(tree.getTotal())).toBe(true)
+        expect(tree.getTotal()).toBe(50 * 30)
+        expect(tree.get(0)).toBe(30)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("findIndexAtOrAfter は materialize:true + ranges でも契約 (cumulative >= target) を満たし連続呼び出しで安定する", () => {
+        // 探索後の prefixSum 内強制具現化が木を変異させ、返却済み cumulative が
+        // 古い状態のままになる契約違反 (50010 < 50100) の再現条件。
+        const valueFn = (i: number) => (i === 500 ? 10 : 100)
+        const tree = new FenwickMapTree(1000, valueFn, { sampleRange: { from: 0, to: 99 }, materialize: true })
+        const opts = { materializeOption: { materialize: true, ranges: [{ from: 0, to: 99 }] } }
+
+        const first = tree.findIndexAtOrAfter(50100, opts)
+        const second = tree.findIndexAtOrAfter(50100, opts)
+        const third = tree.findIndexAtOrAfter(50100, opts)
+
+        // AtOrAfter 契約: cumulative は target 以上
+        expect(first.cumulative).toBeGreaterThanOrEqual(50100)
+        // 同一引数の連続呼び出しは同一結果 (ドリフトしない)
+        expect(second.index).toBe(first.index)
+        expect(second.cumulative).toBe(first.cumulative)
+        expect(third.index).toBe(first.index)
+        expect(third.cumulative).toBe(first.cumulative)
+    })
+
+    it("findIndexAtOrBefore も materialize:true で契約 (cumulative <= target) を満たし連続呼び出しで安定する", () => {
+        const valueFn = (i: number) => (i === 500 ? 10 : 100)
+        const tree = new FenwickMapTree(1000, valueFn, { sampleRange: { from: 0, to: 99 }, materialize: true })
+        const opts = { materializeOption: { materialize: true, ranges: [{ from: 0, to: 99 }] } }
+
+        const first = tree.findIndexAtOrBefore(50100, opts)
+        const second = tree.findIndexAtOrBefore(50100, opts)
+
+        expect(first.cumulative).toBeLessThanOrEqual(50100)
+        expect(second.index).toBe(first.index)
+        expect(second.cumulative).toBe(first.cumulative)
+    })
+
+    it("updates / updateDeltas は非有限値 (NaN/Infinity) を throw で拒否し木を汚染しない", () => {
+        const tree = new FenwickMapTree(10, 10) // total = 100
+        expect(() => tree.updates([{ index: 1, value: Number.NaN }])).toThrow()
+        expect(() => tree.updates([{ index: 1, value: Number.POSITIVE_INFINITY }])).toThrow()
+        expect(() => tree.updateDeltas([{ index: 1, change: Number.NaN }])).toThrow()
+        expect(() => tree.updateDelta(1, Number.NEGATIVE_INFINITY)).toThrow()
+        // 拒否後も木は無傷であること (アトミック性)
+        expect(tree.getTotal()).toBe(100)
+        expect(tree.prefixSum(9).cumulative).toBe(100)
+        expect(tree.get(1)).toBe(10)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("updates は途中に NaN があると先行分も適用しない (アトミック)", () => {
+        const tree = new FenwickMapTree(10, 10) // total = 100
+        expect(() =>
+            tree.updates([
+                { index: 0, value: 50 },
+                { index: 1, value: Number.NaN },
+            ]),
+        ).toThrow()
+        expect(tree.get(0)).toBe(10)
+        expect(tree.getTotal()).toBe(100)
+    })
+})
+
+describe("FenwickMapTree (回帰: r4 監査所見)", () => {
+    it("100 < size < 200 でも後半の多数派が baseValue に採用される (stride=1 盲点の回帰)", () => {
+        // 旧実装は stride = floor(size / 100) が size=101..199 で 1 になり (奇数のため +1 補正も
+        // 効かない)、先頭 100 件しかサンプリングせず後半の多数派を見落としていた。
+        // ceil 化により必ず全域を跨ぐことを size = 101 / 150 / 199 で検証する。
+
+        // size=199: 先頭 99 件が 200px、後半 100 件が 40px (多数派は後半)
+        const tree199 = new FenwickMapTree(199, (i) => (i < 99 ? 200 : 40))
+        expect(tree199.get(150)).toBe(40) // 未具現化行は baseValue を返す
+        expect(tree199.getTotal()).toBe(40 * 199)
+
+        // size=150: 先頭 50 件が 200px、後半 100 件が 40px
+        const tree150 = new FenwickMapTree(150, (i) => (i < 50 ? 200 : 40))
+        expect(tree150.get(100)).toBe(40)
+        expect(tree150.getTotal()).toBe(40 * 150)
+
+        // size=101: 先頭 40 件が 200px、後半 61 件が 40px
+        const tree101 = new FenwickMapTree(101, (i) => (i < 40 ? 200 : 40))
+        expect(tree101.get(100)).toBe(40)
+        expect(tree101.getTotal()).toBe(40 * 101)
+    })
+
+    it("具現化経路 (get/prefixSum の materialize) は valueFn の非有限値を throw で拒否し木を汚染しない", () => {
+        // index 250 だけ NaN を返す valueFn (250 は stride=3 のサンプル点に含まれない)
+        const tree = new FenwickMapTree(300, (i) => (i === 250 ? Number.NaN : 30))
+        // サンプリングは NaN に当たらず baseValue = 30 が確立する
+        expect(tree.get(250)).toBe(30) // 未具現化なら baseValue
+        expect(tree.getTotal()).toBe(30 * 300)
+
+        // NaN 行の具現化は変異前に throw する (update 系と対称)
+        expect(() => tree.get(250, { materializeOption: { materialize: true } })).toThrow()
+        expect(() => tree.prefixSum(299, { materializeOption: { materialize: true, ranges: [{ from: 240, to: 260 }] } })).toThrow()
+
+        // 拒否後も木は無傷 (total / prefixSum が NaN 汚染されない)
+        expect(tree.getTotal()).toBe(30 * 300)
+        expect(tree.prefixSum(299).cumulative).toBe(30 * 300)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("reset のサンプリングで valueFn が非有限値を返すと throw し、木は直前の状態を無傷に保つ (半構築を残さない)", () => {
+        const tree = new FenwickMapTree(10, 10)
+        tree.update(3, 25) // total = 115
+
+        // 小リストパス (サンプル範囲の検証で throw)
+        expect(() => tree.reset(5, () => Number.NaN)).toThrow()
+        // 大リストパス (ストライドサンプリングの検証で throw)
+        expect(() => tree.reset(1000, () => Number.POSITIVE_INFINITY)).toThrow()
+
+        // 旧状態がそのまま残ること
+        expect(tree.getSize()).toBe(10)
+        expect(tree.getTotal()).toBe(115)
+        expect(tree.get(3)).toBe(25)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("updateDelta / updateDeltas は適用後の実効値が負になる change を throw で拒否する", () => {
+        const tree = new FenwickMapTree(10, 10) // baseValue = 10, total = 100
+
+        // 単発で実効値が負になる change
+        expect(() => tree.updateDelta(2, -30)).toThrow()
+        // バッチ内累積で負になる change (各単体では実効値 4 だが累積で -2)
+        expect(() =>
+            tree.updateDeltas([
+                { index: 3, change: -6 },
+                { index: 3, change: -6 },
+            ]),
+        ).toThrow()
+
+        // 拒否後も木は無傷であること (アトミック性)
+        expect(tree.getTotal()).toBe(100)
+        expect(tree.get(2)).toBe(10)
+        expect(tree.get(3)).toBe(10)
+
+        // 実効値 0 ちょうどまでは許容される (updates の value=0 許容と対称)
+        tree.updateDelta(2, -10)
+        expect(tree.get(2)).toBe(0)
+        expect(tree.getTotal()).toBe(90)
+
+        // 累積和の単調性が保たれ、探索契約が壊れないこと
+        // 累積和: [10, 20, 20, 30, ...]
+        expect(tree.findIndexAtOrAfter(15).index).toBe(1)
+        expect(tree.findIndexAtOrBefore(15).index).toBe(0)
+    })
+
+    it("update 系は小数 / NaN の index を throw で拒否し、get / prefixSum も不正 index で木を汚染しない", () => {
+        const tree = new FenwickMapTree(10, 10)
+
+        // 書き込み経路: 小数/NaN index は throw (NaN は範囲比較を素通りするため明示検証)
+        expect(() => tree.update(2.5, 20)).toThrow("Index must be an integer")
+        expect(() => tree.updateDelta(Number.NaN, 5)).toThrow("Index must be an integer")
+
+        // get: 小数/NaN index は範囲外と同様に throw
+        expect(() => tree.get(2.5)).toThrow("Index out of bounds")
+        expect(() => tree.get(Number.NaN)).toThrow("Index out of bounds")
+
+        // prefixSum: 小数は切り捨て、NaN は負 index と同じ中立値へ縮退 (具現化キーを作らない)
+        expect(tree.prefixSum(2.5, { materializeOption: { materialize: true } }).safeIndex).toBe(2)
+        expect(tree.prefixSum(2.5).cumulative).toBe(30)
+        expect(tree.prefixSum(Number.NaN).cumulative).toBe(0)
+        expect(tree.prefixSum(Number.NaN).safeIndex).toBe(0)
+
+        // 木は無傷であること
+        expect(tree.getTotal()).toBe(100)
+        expect(tree.prefixSum(9).cumulative).toBe(100)
+        expect(tree.calculateAccumulatedError()).toBe(0)
+    })
+
+    it("changeSize は非有限サイズを throw で拒否し、小数は切り捨て・負値は 0 に縮退する", () => {
+        const tree = new FenwickMapTree(10, 10)
+
+        expect(() => tree.changeSize(Number.NaN)).toThrow()
+        expect(() => tree.changeSize(Number.POSITIVE_INFINITY)).toThrow()
+        // 拒否後も木は無傷
+        expect(tree.getSize()).toBe(10)
+        expect(tree.getTotal()).toBe(100)
+
+        // 小数は切り捨てて末尾伸長
+        tree.changeSize(12.9)
+        expect(tree.getSize()).toBe(12)
+        expect(tree.getTotal()).toBe(120)
+
+        // 負値は 0 に縮退 (reset の正規化と同一規則)
+        tree.changeSize(-3)
+        expect(tree.getSize()).toBe(0)
+        expect(tree.getTotal()).toBe(0)
+    })
+
+    it("コンストラクタ / reset / フックは NaN・小数の size を安全に正規化する", () => {
+        // コンストラクタ: NaN size は 0 に縮退
+        const tree = new FenwickMapTree(Number.NaN, 10)
+        expect(tree.getSize()).toBe(0)
+        expect(tree.getTotal()).toBe(0)
+
+        // reset: 小数 size は切り捨て
+        tree.reset(7.9, 10)
+        expect(tree.getSize()).toBe(7)
+        expect(tree.getTotal()).toBe(70)
+
+        // フック: Math.max(0, NaN) = NaN の素通りが遮断される
+        const { result } = renderHook(() => useFenwickMapTree(Number.NaN, 10))
+        expect(result.current.getSize()).toBe(0)
+        expect(result.current.getTotal()).toBe(0)
+    })
+
+    it("小リスト reset で from > to の逆転 sampleRange は既定範囲へフォールバックし baseValue=0 に縮退しない", () => {
+        const tree = new FenwickMapTree(20, () => 30, { sampleRange: { from: 10, to: 5 } })
+        expect(tree.get(0)).toBe(30)
+        expect(tree.getTotal()).toBe(20 * 30)
+    })
+})
+
+describe("useFenwickMapTree", () => {
+    it("props が変わらない限りインスタンスは安定しているべき", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; valueOrFn: number | ((i: number) => number) }>(({ size, valueOrFn }) => useFenwickMapTree(size, valueOrFn), {
+            initialProps: { size: 10, valueOrFn: 20 },
+        })
+        const firstInstance = result.current
+        rerender({ size: 10, valueOrFn: 20 })
+        expect(result.current).toBe(firstInstance)
+    })
+
+    it("size が変わっても同じインスタンスになる（安定性保証）", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; valueOrFn: number | ((i: number) => number) }>(({ size, valueOrFn }) => useFenwickMapTree(size, valueOrFn), {
+            initialProps: { size: 10, valueOrFn: 20 },
+        })
+        const firstInstance = result.current
+        rerender({ size: 20, valueOrFn: 20 })
+        expect(result.current).toBe(firstInstance)
+        expect(result.current.getSize()).toBe(20)
+    })
+
+    it("valueOrFn が変わっても同じインスタンスになる（安定性保証）", () => {
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; valueOrFn: number | ((i: number) => number) }>(({ size, valueOrFn }) => useFenwickMapTree(size, valueOrFn), {
+            initialProps: { size: 10, valueOrFn: 20 },
+        })
+        const firstInstance = result.current
+        const newValueFn = (i: number) => i
+        rerender({ size: 10, valueOrFn: newValueFn })
+        expect(result.current).toBe(firstInstance)
+    })
+
+    it("フックから返されたツリーが正しく動作するべき", () => {
+        const { result } = renderHook(() => useFenwickMapTree(5, 10))
+        const tree = result.current
+
+        expect(tree.getTotal()).toBe(50)
+
+        act(() => {
+            tree.update(2, 20)
+        })
+
+        expect(tree.get(2)).toBe(20)
+        expect(tree.getTotal()).toBe(60)
+    })
+
+    it("resetOnValueFnChange=false でも size 0 -> N と valueFn 変更の同時発生で total が確立する (回帰: r3 監査所見)", () => {
+        // 「itemCount=0 でマウント -> データ到着で itemCount>0 + getItemHeight 新識別子」の
+        // ローディングフロー。旧実装は baseValue=0 のまま増分伸長し total=0 で固着していた。
+        const options = { resetOnValueFnChange: false }
+        const fn1 = (_i: number) => 30
+        const fn2 = (_i: number) => 30
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; valueOrFn: number | ((i: number) => number) }>(({ size, valueOrFn }) => useFenwickMapTree(size, valueOrFn, options), {
+            initialProps: { size: 0, valueOrFn: fn1 },
+        })
+        expect(result.current.getTotal()).toBe(0)
+
+        // size 0 -> 200 と valueFn の識別子変更が同一レンダーで発生
+        rerender({ size: 200, valueOrFn: fn2 })
+
+        expect(result.current.getSize()).toBe(200)
+        // reset に倒れて baseValue がサンプリングされ、total が確立すること
+        expect(result.current.getTotal()).toBe(200 * 30)
+        expect(result.current.get(5)).toBe(30)
+    })
+
+    it("resetOnValueFnChange=false で size 0 のまま valueFn が変わっても安全 (0 -> N reset の前提統一)", () => {
+        const options = { resetOnValueFnChange: false }
+        const fn1 = (_i: number) => 30
+        const fn2 = (_i: number) => 40
+        const fn3 = (_i: number) => 40
+        const { result, rerender } = renderHook<FenwickMapTree, { size: number; valueOrFn: number | ((i: number) => number) }>(({ size, valueOrFn }) => useFenwickMapTree(size, valueOrFn, options), {
+            initialProps: { size: 0, valueOrFn: fn1 },
+        })
+
+        // size 0 のまま valueFn だけ変更 (伸長なし) -> total 0 のままで正しい
+        rerender({ size: 0, valueOrFn: fn2 })
+        expect(result.current.getTotal()).toBe(0)
+
+        // その後の 0 -> N 伸長 (valueFn も新識別子) で total が確立すること
+        rerender({ size: 100, valueOrFn: fn3 })
+        expect(result.current.getTotal()).toBe(100 * 40)
+    })
+})