@aiquants/virtualscroll 1.20.0 → 1.22.1

package/src/cli.server.spec.ts

@@ -1,137 +0,0 @@
-/**
- * Regression tests for the CLI entry point: usage guidance must always be
- * printed via console (never suppressed by the Logger's default WARN level),
- * and importing the module must not trigger the CLI.
- * CLI エントリポイントの回帰テスト。usage 案内が Logger の既定レベル (WARN) に
- * 抑制されず常時 console 表示されること、および import 時に CLI が起動しないことの検証。
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-
-// spawn / existsSync をモックし、実プロセス起動・実ファイル参照なしで CLI 分岐を検証する
-vi.mock("node:child_process", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("node:child_process")>()
-    const spawnMock = vi.fn(() => ({ on: vi.fn() }))
-    return {
-        ...actual,
-        default: { ...actual, spawn: spawnMock },
-        spawn: spawnMock,
-    }
-})
-vi.mock("node:fs", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("node:fs")>()
-    // interop で default 経由の名前解決が行われるため、default 側にも同一モックを載せる
-    const existsSyncMock = vi.fn(() => true)
-    return {
-        ...actual,
-        default: { ...actual, existsSync: existsSyncMock },
-        existsSync: existsSyncMock,
-    }
-})
-
-import { spawn } from "node:child_process"
-import { existsSync } from "node:fs"
-import { runCli } from "./cli.server"
-
-const USAGE_MESSAGE = "Usage: npx @aiquants/virtualscroll demo"
-
-describe("cli.server", () => {
-    let consoleErrorSpy: ReturnType<typeof vi.spyOn>
-    let exitSpy: ReturnType<typeof vi.spyOn>
-
-    beforeEach(() => {
-        // console.error を捕捉して usage 案内の常時表示を検証する
-        consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
-        // process.exit は throw に差し替え、以降のコードへ進まない実挙動を再現する
-        exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-            throw new Error(`process.exit(${code})`)
-        }) as never)
-        vi.mocked(spawn).mockClear()
-        vi.mocked(existsSync).mockClear()
-    })
-
-    afterEach(() => {
-        consoleErrorSpy.mockRestore()
-        exitSpy.mockRestore()
-    })
-
-    it("prints unknown command and usage to console.error and exits 1", () => {
-        // 未知コマンドではコマンド名 + usage が console.error 直で表示される (Logger レベル非依存)
-        expect(() => runCli(["foo"])).toThrow("process.exit(1)")
-        const messages = consoleErrorSpy.mock.calls.map((call) => String(call[0]))
-        expect(messages).toContain("Unknown command: foo")
-        expect(messages).toContain(USAGE_MESSAGE)
-    })
-
-    it("prints usage without 'Unknown command: undefined' when no args are given", () => {
-        // 引数なしでは undefined を埋め込んだ Unknown command 行を出さず usage のみ表示する
-        expect(() => runCli([])).toThrow("process.exit(1)")
-        const messages = consoleErrorSpy.mock.calls.map((call) => String(call[0]))
-        expect(messages).toContain(USAGE_MESSAGE)
-        expect(messages.some((message) => message.includes("Unknown command"))).toBe(false)
-    })
-
-    it("prints source-checkout guidance via console.error and exits 1 when demo dir is missing", () => {
-        // demo ディレクトリ不在 (published tarball 相当) では案内を常時表示して exit 1 する
-        vi.mocked(existsSync).mockReturnValue(false)
-        expect(() => runCli(["demo"])).toThrow("process.exit(1)")
-        const messages = consoleErrorSpy.mock.calls.map((call) => String(call[0]))
-        expect(messages.some((message) => message.includes("only available in a source checkout"))).toBe(true)
-        expect(vi.mocked(spawn)).not.toHaveBeenCalled()
-    })
-
-    it("announces startup and spawns the demo server when demo dir exists", () => {
-        // demo ディレクトリが存在する場合は起動メッセージを常時表示し pnpm run dev を spawn する
-        vi.mocked(existsSync).mockReturnValue(true)
-        runCli(["demo"])
-        const messages = consoleErrorSpy.mock.calls.map((call) => String(call[0]))
-        expect(messages).toContain("Starting demo server...")
-        expect(vi.mocked(spawn)).toHaveBeenCalledWith("pnpm", ["run", "dev"], expect.objectContaining({ stdio: "inherit" }))
-        expect(exitSpy).not.toHaveBeenCalled()
-    })
-
-    it("propagates a non-zero child exit code to process.exitCode via the close handler", () => {
-        // 子プロセスが非ゼロ終了したら親の exitCode に伝播する (シェル連結/CI で失敗が成功扱いにならない)
-        const previousExitCode = process.exitCode
-        try {
-            vi.mocked(existsSync).mockReturnValue(true)
-            runCli(["demo"])
-            const onMock = vi.mocked(spawn).mock.results[0]?.value.on as ReturnType<typeof vi.fn>
-            const closeHandler = onMock.mock.calls.find((call) => call[0] === "close")?.[1] as (code: number | null) => void
-            expect(closeHandler).toBeTypeOf("function")
-            closeHandler(3)
-            expect(process.exitCode).toBe(3)
-            // code=null (シグナル終了等) は汎用の 1 にフォールバックする
-            process.exitCode = undefined
-            closeHandler(null)
-            expect(process.exitCode).toBe(1)
-            // 正常終了 (code=0) では exitCode を汚染しない
-            process.exitCode = undefined
-            closeHandler(0)
-            expect(process.exitCode).toBeUndefined()
-        } finally {
-            process.exitCode = previousExitCode
-        }
-    })
-
-    it("sets process.exitCode to 1 when the child emits an error (spawn failure)", () => {
-        // spawn 自体の失敗 (コマンド不在等) も非ゼロ終了として親へ伝播する
-        const previousExitCode = process.exitCode
-        try {
-            vi.mocked(existsSync).mockReturnValue(true)
-            runCli(["demo"])
-            const onMock = vi.mocked(spawn).mock.results[0]?.value.on as ReturnType<typeof vi.fn>
-            const errorHandler = onMock.mock.calls.find((call) => call[0] === "error")?.[1] as (err: Error) => void
-            expect(errorHandler).toBeTypeOf("function")
-            errorHandler(new Error("spawn pnpm ENOENT"))
-            expect(process.exitCode).toBe(1)
-        } finally {
-            process.exitCode = previousExitCode
-        }
-    })
-
-    it("does not run the CLI on import (direct-run guard)", () => {
-        // モジュール import 自体では spawn も exit も発生していない (トップレベルガードの検証)
-        // 上記テスト以外での呼び出しが無いことは各テストの mockClear + アサーションで担保される
-        expect(vi.mocked(spawn)).not.toHaveBeenCalled()
-    })
-})

package/src/logger.spec.ts

@@ -1,128 +0,0 @@
-/**
- * @fileoverview Tests for Logger.
- * Logger のテスト。
- */
-
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { type ILogger, Logger, LogLevel } from "./logger"
-
-const createImpl = (): ILogger => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-})
-
-describe("Logger", () => {
-    let impl: ILogger
-
-    beforeEach(() => {
-        impl = createImpl()
-    })
-
-    it("レベル抑制時は impl を呼ばない", () => {
-        const logger = new Logger(LogLevel.WARN, "[t]", impl)
-        logger.debug("hidden")
-        logger.info("hidden")
-        expect(impl.debug).not.toHaveBeenCalled()
-        expect(impl.info).not.toHaveBeenCalled()
-    })
-
-    it("有効レベルでは prefix 付きで出力する(後方互換)", () => {
-        const logger = new Logger(LogLevel.DEBUG, "[t]", impl)
-        logger.debug("hello", 1, 2)
-        expect(impl.debug).toHaveBeenCalledWith("[t] hello", 1, 2)
-
-        logger.warn({ a: 1 })
-        expect(impl.warn).toHaveBeenCalledWith("[t]", { a: 1 })
-    })
-
-    describe("isEnabled", () => {
-        it("現在のレベルで出力されるレベルのみ true", () => {
-            const logger = new Logger(LogLevel.WARN, "[t]", impl)
-            expect(logger.isEnabled(LogLevel.DEBUG)).toBe(false)
-            expect(logger.isEnabled(LogLevel.INFO)).toBe(false)
-            expect(logger.isEnabled(LogLevel.WARN)).toBe(true)
-            expect(logger.isEnabled(LogLevel.ERROR)).toBe(true)
-        })
-
-        it("静的インスタンスにも isEnabled がある", () => {
-            Logger.setLevel(LogLevel.ERROR)
-            expect(Logger.isEnabled(LogLevel.WARN)).toBe(false)
-            expect(Logger.isEnabled(LogLevel.ERROR)).toBe(true)
-            Logger.setLevel(LogLevel.WARN)
-        })
-    })
-
-    describe("遅延評価(サンク)引数", () => {
-        it("抑制時はサンクを一切呼ばない(オブジェクト生成/DOM 読み取りを回避)", () => {
-            const logger = new Logger(LogLevel.WARN, "[t]", impl)
-            const messageThunk = vi.fn(() => "expensive message")
-            const paramThunk = vi.fn(() => ({ heavy: true }))
-
-            logger.debug(messageThunk, paramThunk)
-
-            expect(messageThunk).not.toHaveBeenCalled()
-            expect(paramThunk).not.toHaveBeenCalled()
-            expect(impl.debug).not.toHaveBeenCalled()
-        })
-
-        it("有効時はサンクを解決して出力する", () => {
-            const logger = new Logger(LogLevel.DEBUG, "[t]", impl)
-            const messageThunk = vi.fn(() => "expensive message")
-            const paramThunk = vi.fn(() => ({ heavy: true }))
-
-            logger.debug(messageThunk, paramThunk)
-
-            expect(messageThunk).toHaveBeenCalledTimes(1)
-            expect(paramThunk).toHaveBeenCalledTimes(1)
-            expect(impl.debug).toHaveBeenCalledWith("[t] expensive message", { heavy: true })
-        })
-
-        it("非関数値はそのまま素通し(後方互換)", () => {
-            const logger = new Logger(LogLevel.INFO, "[t]", impl)
-            logger.info("plain", { a: 1 }, 3)
-            expect(impl.info).toHaveBeenCalledWith("[t] plain", { a: 1 }, 3)
-        })
-
-        it("class を渡してもクラッシュせず、元のクラス値をそのまま出力する", () => {
-            const logger = new Logger(LogLevel.ERROR, "[t]", impl)
-            class Foo {}
-
-            // class constructor は `new` なしで呼べないが、logger 呼び出しは throw しない
-            expect(() => logger.error("failed with handler:", Foo)).not.toThrow()
-            expect(impl.error).toHaveBeenCalledWith("[t] failed with handler:", Foo)
-
-            // message 位置に class を渡してもクラッシュしない
-            expect(() => logger.error(Foo)).not.toThrow()
-            expect(impl.error).toHaveBeenCalledWith("[t]", Foo)
-        })
-
-        it("thunk が throw しても例外を伝播させず、元の関数値を出力する", () => {
-            const logger = new Logger(LogLevel.DEBUG, "[t]", impl)
-            const badThunk = () => {
-                throw new Error("boom in thunk")
-            }
-
-            // レベル有効時でもログ呼び出しは呼び出し元に例外を伝播させない
-            expect(() => logger.debug("state:", badThunk)).not.toThrow()
-            // 握り潰しではなく、元の関数値がログに出力される
-            expect(impl.debug).toHaveBeenCalledWith("[t] state:", badThunk)
-
-            // message 位置の thunk が throw するケースも同様
-            expect(() => logger.debug(badThunk)).not.toThrow()
-            expect(impl.debug).toHaveBeenCalledWith("[t]", badThunk)
-        })
-
-        it("抑制レベルでは throw する thunk も一切評価されない", () => {
-            const logger = new Logger(LogLevel.WARN, "[t]", impl)
-            const badThunk = vi.fn(() => {
-                throw new Error("boom in thunk")
-            })
-
-            expect(() => logger.debug(badThunk)).not.toThrow()
-            expect(badThunk).not.toHaveBeenCalled()
-            expect(impl.debug).not.toHaveBeenCalled()
-        })
-    })
-})

package/src/useFenwickMapTree.huge.spec.ts

@@ -1,388 +0,0 @@
-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
-})
-
-const MAX_SAFE_BIG = BigInt(Number.MAX_SAFE_INTEGER)
-const EXACT_SIZE = Number.MAX_SAFE_INTEGER
-const SHRUNK_SIZE = Number(MAX_SAFE_BIG - 64n)
-const HEAD_INDEX = 0
-const SECOND_INDEX = 1
-const MID_INDEX = Number(MAX_SAFE_BIG - 512n)
-const BEFORE_MID_INDEX = MID_INDEX - 1
-const PRE_TAIL_INDEX = Number(MAX_SAFE_BIG - 8n)
-const BEFORE_PRE_TAIL_INDEX = PRE_TAIL_INDEX - 1
-const TAIL_INDEX = Number(MAX_SAFE_BIG - 1n)
-const BEFORE_TAIL_INDEX = TAIL_INDEX - 1
-const SAMPLE_RANGE_NEAR_TAIL = {
-    from: Number(MAX_SAFE_BIG - 16n),
-    to: TAIL_INDEX,
-}
-
-describe("FenwickMapTree (最大安全整数近傍)", () => {
-    it("最大安全整数サイズで基礎的な取得ができる", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        expect(tree.getSize()).toBe(EXACT_SIZE)
-        expect(tree.getTotal()).toBe(0)
-        expect(tree.get(HEAD_INDEX)).toBe(0)
-        expect(tree.get(TAIL_INDEX)).toBe(0)
-    })
-
-    it("最大安全整数サイズで複数インデックスを更新しても累積和が安全に計算できる", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-        tree.update(SECOND_INDEX, 3)
-        tree.update(MID_INDEX, 4)
-        tree.update(PRE_TAIL_INDEX, 7)
-        tree.update(TAIL_INDEX, 9)
-
-        expect(tree.prefixSum(HEAD_INDEX).cumulative).toBe(5)
-        expect(tree.prefixSum(SECOND_INDEX).cumulative).toBe(8)
-        expect(tree.prefixSum(MID_INDEX).cumulative).toBe(12)
-        expect(tree.prefixSum(PRE_TAIL_INDEX).cumulative).toBe(19)
-        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(28)
-        expect(tree.getTotal()).toBe(28)
-    })
-
-    it("最大安全整数サイズで findIndexAtOrAfter が閾値に対応する", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-        tree.update(SECOND_INDEX, 3)
-        tree.update(MID_INDEX, 4)
-        tree.update(PRE_TAIL_INDEX, 7)
-        tree.update(TAIL_INDEX, 9)
-
-        expect(tree.findIndexAtOrAfter(1).index).toBe(HEAD_INDEX)
-        expect(tree.findIndexAtOrAfter(8).index).toBe(SECOND_INDEX)
-        expect(tree.findIndexAtOrAfter(12).index).toBe(MID_INDEX)
-        expect(tree.findIndexAtOrAfter(19).index).toBe(PRE_TAIL_INDEX)
-        expect(tree.findIndexAtOrAfter(28).index).toBe(TAIL_INDEX)
-        expect(tree.findIndexAtOrAfter(29).index).toBe(-1)
-    })
-
-    it("最大安全整数サイズで findIndexAtOrBefore が閾値に対応する", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-        tree.update(SECOND_INDEX, 3)
-        tree.update(MID_INDEX, 4)
-        tree.update(PRE_TAIL_INDEX, 7)
-        tree.update(TAIL_INDEX, 9)
-
-        expect(tree.findIndexAtOrBefore(4).index).toBe(-1)
-        expect(tree.findIndexAtOrBefore(5).index).toBe(HEAD_INDEX)
-        expect(tree.findIndexAtOrBefore(8).index).toBe(BEFORE_MID_INDEX)
-        expect(tree.findIndexAtOrBefore(12).index).toBe(BEFORE_PRE_TAIL_INDEX)
-        expect(tree.findIndexAtOrBefore(19).index).toBe(BEFORE_TAIL_INDEX)
-        expect(tree.findIndexAtOrBefore(28).index).toBe(TAIL_INDEX)
-    })
-
-    it("巨大サイズで updates がまとめて適用される", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.updates([
-            { index: HEAD_INDEX, value: 6 },
-            { index: MID_INDEX, value: 4 },
-            { index: TAIL_INDEX, value: 8 },
-        ])
-
-        expect(tree.get(HEAD_INDEX)).toBe(6)
-        expect(tree.prefixSum(MID_INDEX).cumulative).toBe(10)
-        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(18)
-        expect(tree.getTotal()).toBe(18)
-    })
-
-    it("巨大サイズで updateDelta が差分を加算できる", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.updateDelta(TAIL_INDEX, 5)
-        tree.updateDelta(TAIL_INDEX, 3)
-        tree.updateDelta(HEAD_INDEX, 4)
-
-        expect(tree.get(TAIL_INDEX)).toBe(8)
-        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(12)
-        expect(tree.getTotal()).toBe(12)
-    })
-
-    it("巨大サイズで changeSize を縮小すると範囲外デルタが除去される", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-        tree.update(TAIL_INDEX, 9)
-
-        tree.changeSize(SHRUNK_SIZE)
-
-        expect(tree.getSize()).toBe(SHRUNK_SIZE)
-        expect(() => tree.get(TAIL_INDEX)).toThrow()
-        expect(tree.getTotal()).toBe(5)
-    })
-
-    it("巨大サイズで changeSize を拡大した後でも更新ができる", () => {
-        const tree = new FenwickMapTree(SHRUNK_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-
-        tree.changeSize(EXACT_SIZE)
-        tree.update(TAIL_INDEX, 11)
-
-        expect(tree.getSize()).toBe(EXACT_SIZE)
-        expect(tree.get(TAIL_INDEX)).toBe(11)
-        expect(tree.prefixSum(TAIL_INDEX).cumulative).toBe(16)
-    })
-
-    it("巨大サイズで rebuildTree を呼んでも合計値が維持される", () => {
-        const tree = new FenwickMapTree(EXACT_SIZE, 0)
-
-        tree.update(HEAD_INDEX, 5)
-        tree.update(PRE_TAIL_INDEX, 7)
-
-        tree.rebuildTree()
-
-        expect(tree.get(HEAD_INDEX)).toBe(5)
-        expect(tree.get(PRE_TAIL_INDEX)).toBe(7)
-        expect(tree.getTotal()).toBe(12)
-    })
-
-    it("巨大サイズで valueFn による遅延具現化が機能する", () => {
-        const tree = new FenwickMapTree(
-            EXACT_SIZE,
-            (index) => {
-                if (index === HEAD_INDEX) {
-                    return 4
-                }
-                if (index === TAIL_INDEX) {
-                    return 6
-                }
-                return 0
-            },
-            { sampleRange: { from: 0, to: 16 }, materialize: false },
-        )
-
-        const head = tree.get(HEAD_INDEX, { materializeOption: { materialize: true } })
-        const tail = tree.get(TAIL_INDEX, { materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
-        const total = tree.getTotal({ materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
-
-        expect(head).toBe(4)
-        expect(tail).toBe(6)
-        expect(total).toBe(10)
-    })
-
-    it("巨大サイズの +1 末尾追記でも delta と total が正確 (回帰: r3 監査所見)", () => {
-        const tree = new FenwickMapTree(SHRUNK_SIZE, 0)
-        tree.update(HEAD_INDEX, 5)
-        tree.update(SHRUNK_SIZE - 1, 7)
-
-        tree.changeSize(SHRUNK_SIZE + 1)
-
-        expect(tree.getSize()).toBe(SHRUNK_SIZE + 1)
-        expect(tree.getTotal()).toBe(12)
-        expect(tree.prefixSum(SHRUNK_SIZE).cumulative).toBe(12)
-        expect(tree.get(SHRUNK_SIZE)).toBe(0)
-    })
-
-    it("巨大サイズ (bigint 探索パス) の findIndexAtOrAfter は materialize:true でも契約を満たし連続呼び出しで安定する (回帰: r3 監査所見)", () => {
-        // size >= 2^30 で _findIndexLarge (bigint 二分探索) に委譲されるパスの検証
-        const size = 0x80000000 // 2^31
-        const valueFn = (index: number) => (index === 500 ? 10 : 100)
-        const tree = new FenwickMapTree(size, 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)
-
-        // AtOrAfter 契約: cumulative は target 以上
-        expect(first.cumulative).toBeGreaterThanOrEqual(50100)
-        // 同一引数の連続呼び出しは同一結果 (探索後の木変異によるドリフトがない)
-        expect(second.index).toBe(first.index)
-        expect(second.cumulative).toBe(first.cumulative)
-    })
-
-    it("巨大サイズ (bigint 探索パス) の未発見時は小サイズパスと同一契約で cumulative などが undefined になる (回帰: r4 監査所見)", () => {
-        // 旧実装は bestResult ?? lastResult のフォールバックにより、未発見 (index=-1) でも
-        // 最後にプローブした位置の cumulative/currentValue/safeIndex が載っていた
-        // (AtOrBefore の未発見時は cumulative > target という契約矛盾の値になる)。
-        const size = 0x40000000 // 2^30 (bigint 探索パスの下限)
-        const tree = new FenwickMapTree(size, 10)
-
-        // AtOrAfter: total を超える target は未発見
-        const after = tree.findIndexAtOrAfter(Number.MAX_SAFE_INTEGER)
-        expect(after.index).toBe(-1)
-        expect(after.cumulative).toBeUndefined()
-        expect(after.currentValue).toBeUndefined()
-        expect(after.safeIndex).toBeUndefined()
-
-        // AtOrBefore: どの累積和よりも小さい target は未発見
-        const before = tree.findIndexAtOrBefore(-1)
-        expect(before.index).toBe(-1)
-        expect(before.cumulative).toBeUndefined()
-        expect(before.currentValue).toBeUndefined()
-        expect(before.safeIndex).toBeUndefined()
-
-        // 小サイズパスと同一契約であることの対照確認
-        const small = new FenwickMapTree(1000, 10)
-        const smallAfter = small.findIndexAtOrAfter(Number.MAX_SAFE_INTEGER)
-        expect(smallAfter.index).toBe(-1)
-        expect(smallAfter.cumulative).toBeUndefined()
-        expect(smallAfter.safeIndex).toBeUndefined()
-    })
-
-    it("巨大サイズで materialize 範囲を指定して prefixSum が反映される", () => {
-        const tree = new FenwickMapTree(
-            EXACT_SIZE,
-            (index) => {
-                if (index === PRE_TAIL_INDEX) {
-                    return 7
-                }
-                if (index === TAIL_INDEX) {
-                    return 5
-                }
-                return 0
-            },
-            { sampleRange: SAMPLE_RANGE_NEAR_TAIL, materialize: false },
-        )
-
-        const prefix = tree.prefixSum(TAIL_INDEX, { materializeOption: { materialize: true, ranges: [SAMPLE_RANGE_NEAR_TAIL] } })
-
-        expect(prefix.currentValue).toBe(5)
-        expect(prefix.cumulative).toBe(12)
-        expect(prefix.total).toBe(12)
-    })
-})
-
-describe("useFenwickMapTree (最大安全整数近傍)", () => {
-    it("最大安全整数サイズで同一パラメーターならインスタンスが安定する", () => {
-        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
-            initialProps: { size: EXACT_SIZE, value: 0 },
-        })
-
-        const first = result.current
-
-        rerender({ size: EXACT_SIZE, value: 0 })
-
-        expect(result.current).toBe(first)
-    })
-
-    it("最大安全整数サイズでサイズが変わっても同じインスタンスになる（安定性保証）", () => {
-        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
-            initialProps: { size: EXACT_SIZE, value: 0 },
-        })
-
-        const first = result.current
-
-        rerender({ size: SHRUNK_SIZE, value: 0 })
-
-        expect(result.current).toBe(first)
-    })
-
-    it("最大安全整数サイズで valueFn が変わっても同じインスタンスになる（安定性保証）", () => {
-        const { result, rerender } = renderHook<FenwickMapTree, { size: number; value: number | ((index: number) => number) }>(({ size, value }) => useFenwickMapTree(size, value), {
-            initialProps: { size: EXACT_SIZE, value: 0 },
-        })
-
-        const first = result.current
-
-        rerender({
-            size: EXACT_SIZE,
-            value: (index: number) => {
-                if (index === HEAD_INDEX) {
-                    return 2
-                }
-                return 0
-            },
-        })
-
-        expect(result.current).toBe(first)
-    })
-
-    it("最大安全整数サイズで返却されたツリーが更新を反映する", () => {
-        const { result } = renderHook(() => useFenwickMapTree(EXACT_SIZE, 0))
-
-        act(() => {
-            result.current.update(HEAD_INDEX, 5)
-            result.current.update(TAIL_INDEX, 9)
-        })
-
-        expect(result.current.get(HEAD_INDEX)).toBe(5)
-        expect(result.current.get(TAIL_INDEX)).toBe(9)
-        expect(result.current.prefixSum(TAIL_INDEX).cumulative).toBe(14)
-    })
-})
-
-describe("FenwickMapTree (100 Billion items & 1 Trillion items)", () => {
-    const HUNDRED_BILLION = 100_000_000_000
-
-    it("works without infinite loop for 100 Billion items", () => {
-        // Initialize with default item size 20
-        const tree = new FenwickMapTree(HUNDRED_BILLION, 20)
-
-        // This operation triggers _findIndex or _findIndexLarge
-        // Before fix: loop around 2^31 -> hang
-        // After fix: uses _findIndexLarge -> success
-
-        // Target 1000.
-        // Index 49: cumulative = (49+1)*20 = 1000. 1000 >= 1000. Found.
-        const targetOffset = 20 * 50
-        const result = tree.findIndexAtOrAfter(targetOffset)
-
-        expect(result.index).toBe(49)
-        expect(result.cumulative).toBe(targetOffset)
-    })
-
-    it("works for size just related to bitwise boundary (3 Billion)", () => {
-        const THREE_BILLION = 3_000_000_000
-        const tree = new FenwickMapTree(THREE_BILLION, 10)
-        // 10 * 60 = 600.
-        // Index 59: (59+1)*10 = 600.
-        const result = tree.findIndexAtOrAfter(10 * 60)
-        expect(result.index).toBe(59)
-    })
-
-    it("(a) does not hang at the 2^30 bitwise-doubling boundary", () => {
-        // size = 2^30 はビット倍加ループが Int32 オーバーフローする中間域。
-        // 修正前: bit << 1 が -2^31 に化けて無限ループ (タイムアウト)。
-        const tree = new FenwickMapTree(0x40000000, 10) // 2^30 = 1,073,741,824
-        // index 9: cumulative = (9+1)*10 = 100 >= 100
-        const result = tree.findIndexAtOrAfter(100)
-        expect(result.index).toBe(9)
-        expect(result.cumulative).toBe(100)
-    })
-
-    it("(a) does not hang for sizes in [2^30, 2^31-1] (max 32-bit signed)", () => {
-        const tree = new FenwickMapTree(0x7fffffff, 10) // 2^31 - 1 = 2,147,483,647
-        const result = tree.findIndexAtOrAfter(100)
-        expect(result.index).toBe(9)
-        expect(result.cumulative).toBe(100)
-
-        const before = tree.findIndexAtOrBefore(100)
-        expect(before.index).toBe(9)
-    })
-
-    it("works for 1 Trillion items (1,000,000,000,000)", () => {
-        const TRILLION = 1_000_000_000_000
-        // Need to ensure total height fits in safe integer.
-        // MAX safe integer ~9 Quadrillion.
-        // 1 Trillion * 25 = 25 Trillion on safe side.
-        const itemSize = 25
-        const tree = new FenwickMapTree(TRILLION, itemSize)
-
-        const indexToFind = 500_000_000_000 // 500 Billion
-        const targetOffset = itemSize * (indexToFind + 1)
-        const result = tree.findIndexAtOrAfter(targetOffset)
-
-        expect(result.index).toBe(indexToFind)
-        expect(result.cumulative).toBe(targetOffset)
-    })
-})