@aiquants/virtualscroll 1.19.3 → 1.22.0

package/src/useFenwickMapTree.spec.ts

@@ -1,1518 +0,0 @@
-/**
- * @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)
-    })
-})