@uzuhq/code-sdk 0.7.6 → 0.7.7

package/dist/dev-hooks.test.js

@@ -1,294 +0,0 @@
-/**
- * dev-hooks.ts の unit test。
- *
- * カバー対象:
- * - createDevHooks: read / send / setRawState / mergeRawState / patchRawState /
- *   waitForSnapshot の API contract
- * - attachDevHooks: window.__uzu_dev への代入と上書き
- *
- * applyJsonMergePatch / applyJsonPatch そのものの単体テストは
- * `dev-state-patch.test.ts` に分離。
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { attachDevHooks, createDevHooks } from './dev-hooks.js';
-import { applyJsonMergePatch, applyJsonPatch } from './dev-state-patch.js';
-function makeState() {
-    return {
-        game: { currentPhaseId: 'phase_a', timerEndsAt: 1000 },
-        players: {
-            p1: { ready: false, name: 'Alice' },
-            p2: { ready: false, name: 'Bob' },
-        },
-        scenario: { id: 'scenario_1' },
-        tags: ['initial'],
-    };
-}
-describe('createDevHooks', () => {
-    function makeCtx(overrides = {}) {
-        // setRawState で参照ごと差し替えられるよう wrap する。test 側の expect は
-        // box.current 経由で常に最新参照を読む。
-        const box = { current: makeState() };
-        const listeners = new Set();
-        const sendAction = vi.fn();
-        const notify = (snap) => {
-            listeners.forEach((cb) => cb(snap));
-        };
-        const ctx = {
-            getSnapshot: () => box.current,
-            getRawState: () => box.current,
-            setRawState: async (next) => {
-                box.current = next;
-            },
-            mergeRawState: async (patch) => {
-                applyJsonMergePatch(box.current, patch);
-            },
-            patchRawState: async (ops) => {
-                applyJsonPatch(box.current, ops);
-            },
-            playerId: () => 'p1',
-            sendAction,
-            subscribeSnapshot: (cb) => {
-                listeners.add(cb);
-                return () => {
-                    listeners.delete(cb);
-                };
-            },
-            ...overrides,
-        };
-        return { ctx, state: box, notify, sendAction };
-    }
-    it('Read API: getSnapshot / getRawState / playerId を返す', () => {
-        const { ctx, state } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.getSnapshot()).toBe(state.current);
-        expect(hooks.getRawState()).toBe(state.current);
-        expect(hooks.playerId()).toBe('p1');
-    });
-    it('send() は ctx.sendAction に args オブジェクトをそのまま渡す', () => {
-        const { ctx, sendAction } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.send).toBeDefined();
-        hooks.send({ as: 'p2', type: 'vote', payload: { target: 'p1' } });
-        expect(sendAction).toHaveBeenCalledWith({
-            as: 'p2',
-            type: 'vote',
-            payload: { target: 'p1' },
-        });
-    });
-    it('ctx.sendAction 未提供だと hooks.send は undefined', () => {
-        const { ctx } = makeCtx({ sendAction: undefined });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.send).toBeUndefined();
-    });
-    it('send() は ctx.sendAction の rejection をそのまま伝搬する', async () => {
-        const sendActionReject = vi.fn(() => Promise.reject(new Error('Not your turn')));
-        const { ctx } = makeCtx({ sendAction: sendActionReject });
-        const hooks = createDevHooks(ctx);
-        await expect(hooks.send({ as: 'p1', type: 't' })).rejects.toThrow('Not your turn');
-    });
-    // ─── setRawState (全置換) ─────────────────────────
-    it('setRawState() は Promise を返し state を全置換する', async () => {
-        const { ctx, state } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        const next = {
-            game: { currentPhaseId: 'phase_z', timerEndsAt: 999 },
-            players: { px: { ready: true, name: 'X' } },
-            scenario: null,
-        };
-        await expect(hooks.setRawState(next)).resolves.toBeUndefined();
-        expect(state.current).toBe(next);
-        // 旧 state にあった players.p1 は新 state に含まれないので消える (= 全置換意味)
-        expect(state.current.players.p1).toBeUndefined();
-    });
-    it('ctx.setRawState 未提供だと hooks.setRawState は undefined', () => {
-        const { ctx } = makeCtx({ setRawState: undefined });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.setRawState).toBeUndefined();
-    });
-    // ─── mergeRawState (RFC 7396 風 merge patch) ─────
-    it('mergeRawState() は object 階層を recursive merge する', async () => {
-        const { ctx, state } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.mergeRawState).toBeDefined();
-        await hooks.mergeRawState({ players: { p1: { ready: true } } });
-        expect(state.current.players.p1.ready).toBe(true);
-        expect(state.current.players.p1.name).toBe('Alice');
-        expect(state.current.players.p2.ready).toBe(false);
-    });
-    it('mergeRawState() で array に object patch を当てると rejection になる', async () => {
-        const { ctx } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        await expect(hooks.mergeRawState({ tags: { 0: 'oops' } })).rejects.toThrow(/refusing to merge a plain object into array field/);
-    });
-    it('ctx.mergeRawState 未提供だと hooks.mergeRawState は undefined', () => {
-        const { ctx } = makeCtx({ mergeRawState: undefined });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.mergeRawState).toBeUndefined();
-    });
-    // ─── patchRawState (RFC 6902 json patch) ─────────
-    it('patchRawState() は path-based ops を順に適用する', async () => {
-        const { ctx, state } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.patchRawState).toBeDefined();
-        await hooks.patchRawState([
-            { op: 'replace', path: '/game/currentPhaseId', value: 'phase_b' },
-            { op: 'replace', path: '/players/p1/ready', value: true },
-            { op: 'add', path: '/tags/-', value: 'extra' },
-        ]);
-        expect(state.current.game.currentPhaseId).toBe('phase_b');
-        expect(state.current.players.p1.ready).toBe(true);
-        expect(state.current.tags).toEqual(['initial', 'extra']);
-    });
-    it('ctx.patchRawState 未提供だと hooks.patchRawState は undefined', () => {
-        const { ctx } = makeCtx({ patchRawState: undefined });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.patchRawState).toBeUndefined();
-    });
-    it('tick 制御: ctx で提供されると hooks に wire される', () => {
-        const pauseTick = vi.fn();
-        const resumeTick = vi.fn();
-        const stepTick = vi.fn();
-        const { ctx } = makeCtx({
-            pauseTick,
-            resumeTick,
-            stepTick,
-            getCurrentTick: () => 42,
-            isTickPaused: () => true,
-        });
-        const hooks = createDevHooks(ctx);
-        hooks.pauseTick();
-        hooks.resumeTick();
-        hooks.stepTick(3);
-        expect(pauseTick).toHaveBeenCalledOnce();
-        expect(resumeTick).toHaveBeenCalledOnce();
-        expect(stepTick).toHaveBeenCalledWith(3);
-        expect(hooks.getCurrentTick()).toBe(42);
-        expect(hooks.isTickPaused()).toBe(true);
-    });
-    it('tick 制御: ctx 未提供だと hooks 側でも undefined のまま', () => {
-        const { ctx } = makeCtx(); // pauseTick 等を渡さない
-        const hooks = createDevHooks(ctx);
-        expect(hooks.pauseTick).toBeUndefined();
-        expect(hooks.resumeTick).toBeUndefined();
-        expect(hooks.stepTick).toBeUndefined();
-        expect(hooks.getCurrentTick).toBeUndefined();
-        expect(hooks.isTickPaused).toBeUndefined();
-    });
-    it('reset: ctx で提供されると hooks に wire され opts がそのまま渡る', () => {
-        const reset = vi.fn();
-        const { ctx } = makeCtx({ reset });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.reset).toBeDefined();
-        hooks.reset();
-        expect(reset).toHaveBeenCalledWith(undefined);
-        hooks.reset({ seed: 7 });
-        expect(reset).toHaveBeenLastCalledWith({ seed: 7 });
-        hooks.reset({ seed: 'random' });
-        expect(reset).toHaveBeenLastCalledWith({ seed: 'random' });
-    });
-    it('reset: ctx 未提供だと hooks.reset は undefined', () => {
-        const { ctx } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.reset).toBeUndefined();
-    });
-    it('subscribeSnapshot: notify を listen し unsubscribe 後は呼ばれない', () => {
-        const { ctx, state, notify } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        const trace = [];
-        const unsub = hooks.subscribeSnapshot((s) => {
-            trace.push(s.game.currentPhaseId);
-        });
-        state.current.game.currentPhaseId = 'phase_b';
-        notify(state.current);
-        state.current.game.currentPhaseId = 'phase_c';
-        notify(state.current);
-        expect(trace).toEqual(['phase_b', 'phase_c']);
-        unsub();
-        state.current.game.currentPhaseId = 'phase_d';
-        notify(state.current);
-        expect(trace).toEqual(['phase_b', 'phase_c']);
-    });
-    it('subscribeEvents: ctx で提供されると hooks に wire される', () => {
-        const subscribeEvents = vi.fn(() => () => { });
-        const { ctx } = makeCtx({ subscribeEvents });
-        const hooks = createDevHooks(ctx);
-        expect(hooks.subscribeEvents).toBeDefined();
-        const cb = (_evts) => { };
-        hooks.subscribeEvents(cb);
-        expect(subscribeEvents).toHaveBeenCalledWith(cb);
-    });
-    it('subscribeEvents: ctx 未提供だと hooks.subscribeEvents は undefined', () => {
-        const { ctx } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        expect(hooks.subscribeEvents).toBeUndefined();
-    });
-    it('subscribeEvents: unsubscribe 関数がそのまま戻る', () => {
-        const unsubscribe = vi.fn();
-        const subscribeEvents = vi.fn(() => unsubscribe);
-        const { ctx } = makeCtx({ subscribeEvents });
-        const hooks = createDevHooks(ctx);
-        const off = hooks.subscribeEvents(() => { });
-        off();
-        expect(unsubscribe).toHaveBeenCalledOnce();
-    });
-    it('waitForSnapshot: predicate が即時 true なら現在 snapshot で resolve', async () => {
-        const { ctx } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        const result = await hooks.waitForSnapshot((s) => s.game.currentPhaseId === 'phase_a');
-        expect(result.game.currentPhaseId).toBe('phase_a');
-    });
-    it('waitForSnapshot: predicate が false なら subscribe で待ち、notify で resolve', async () => {
-        const { ctx, state, notify } = makeCtx();
-        const hooks = createDevHooks(ctx);
-        const promise = hooks.waitForSnapshot((s) => s.game.currentPhaseId === 'phase_b');
-        state.current.game.currentPhaseId = 'phase_b';
-        notify(state.current);
-        const result = await promise;
-        expect(result.game.currentPhaseId).toBe('phase_b');
-    });
-    it('waitForSnapshot: timeoutMs 経過で reject する', async () => {
-        const { ctx, state } = makeCtx();
-        // 初期 snapshot は phase_a なので、phase_b 待ちはタイムアウトする
-        state.current.game.currentPhaseId = 'phase_a';
-        const hooks = createDevHooks(ctx);
-        await expect(hooks.waitForSnapshot((s) => s.game.currentPhaseId === 'phase_b', {
-            timeoutMs: 50,
-        })).rejects.toThrow(/timed out/);
-    });
-});
-describe('attachDevHooks', () => {
-    afterEach(() => {
-        delete window.__uzu_dev;
-    });
-    it('window.__uzu_dev に hooks を attach する', () => {
-        const state = makeState();
-        attachDevHooks({
-            getSnapshot: () => state,
-            playerId: () => 'p1',
-            sendAction: vi.fn(),
-            subscribeSnapshot: () => () => { },
-        });
-        expect(window.__uzu_dev).toBeDefined();
-        expect(window.__uzu_dev.playerId()).toBe('p1');
-    });
-    it('複数回 attach すると最後のものに置き換わる (silently, no warn)', () => {
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        attachDevHooks({
-            getSnapshot: () => 'first',
-            playerId: () => 'first_id',
-            sendAction: vi.fn(),
-            subscribeSnapshot: () => () => { },
-        });
-        attachDevHooks({
-            getSnapshot: () => 'second',
-            playerId: () => 'second_id',
-            sendAction: vi.fn(),
-            subscribeSnapshot: () => () => { },
-        });
-        expect(window.__uzu_dev.playerId()).toBe('second_id');
-        expect(window.__uzu_dev.getSnapshot()).toBe('second');
-        // init() -> run() の順で 2 回 attach されるのは正常フローなので warn を出さない契約
-        expect(warnSpy).not.toHaveBeenCalled();
-        warnSpy.mockRestore();
-    });
-});

package/dist/dev-prediction-traps.d.ts

@@ -1,32 +0,0 @@
-/**
- * @docs
- * - ServerAction仕様: docs/docs/uzu_code/connection-method/arch3-authority.md
- * - 開発パターン: docs/docs/uzu_code/sdk-guide/patterns.md
- *
- * 素の action handler のクライアント先読み実行中に、サーバーと結果が一致しない API
- * (実時刻 / 乱数) が呼ばれたら警告する。
- *
- * 先読みは「サーバーと同じコードを同じ入力で走らせれば同じ結果になる」ことが前提で、
- * 実時刻や乱数を読むとその前提が崩れる。ズレた state は一瞬表示されたあと ack で
- * 上書きされ、画面が飛ぶ。
- *
- * 静的解析ではなく実行時に差し替えるのは、handler がヘルパー関数を何段挟んでいても
- * 捕まえたいから。同じ理由で、演出用途 (描画ループの `Math.sin(Date.now() / 400)` など)
- * は先読み経路を通らないので原理的に誤検知しない。
- */
-export interface PredictionWarning {
-    /** 呼び出した action 名 */
-    action: string;
-    /** 呼ばれた API 名 (`'Date.now()'` など) */
-    api: string;
-}
-/**
- * 素の action handler の先読み実行を計装して走らせる。
- *
- * Flutter native ホスト (本番) では計装せず素通しする。判定基準は dev hooks と同じ。
- */
-export declare const runPredicted: (action: string, run: () => void) => void;
-/** 検出済みの警告一覧。`__uzu_dev.getPredictionWarnings()` から E2E で assert する用。 */
-export declare const getPredictionWarnings: () => readonly PredictionWarning[];
-/** 検出結果をリセットする (テスト用)。 */
-export declare const clearPredictionWarnings: () => void;

package/dist/dev-prediction-traps.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dev-prediction-traps.test.js

@@ -1,178 +0,0 @@
-/**
- * dev-prediction-traps.ts の unit test。
- *
- * 素の action handler をクライアント先読みで実行する間だけグローバルを差し替え、
- * サーバーと結果が一致しない API (実時刻 / 乱数) の呼び出しを検出する仕組みを検証する。
- *
- * カバー対象:
- * - 検出対象 API それぞれが記録されること
- * - ヘルパー関数を経由した呼び出しも捕まえること (静的解析では追えない経路)
- * - 同じ action / API の重複を 1 件に畳むこと
- * - 実行後にグローバルが必ず元へ戻ること (例外時も含む)
- * - 先読みの外では計装されていないこと
- * - 本番 (Flutter native ホスト) では計装しないこと
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { clearPredictionWarnings, getPredictionWarnings, runPredicted, } from './dev-prediction-traps.js';
-beforeEach(() => {
-    clearPredictionWarnings();
-    // 警告本文は console に出るので、テスト出力を汚さないよう黙らせる。
-    vi.spyOn(console, 'groupCollapsed').mockImplementation(() => { });
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'groupEnd').mockImplementation(() => { });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    delete window.FlutterHost;
-});
-describe('runPredicted', () => {
-    /** 検出対象 API を先読み中に呼ぶと、action 名とセットで記録される。 */
-    describe('非決定的な API の検出', () => {
-        it('Date.now() を記録する', () => {
-            runPredicted('gm.timer.set', () => {
-                Date.now();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'gm.timer.set', api: 'Date.now()' }]);
-        });
-        it('引数なしの new Date() を記録する', () => {
-            runPredicted('startPresentation', () => {
-                new Date();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'startPresentation', api: 'new Date()' }]);
-        });
-        /**
-         * 引数付きの new Date() は与えられた値から決まるので、サーバーと結果がズレない。
-         * 誤検知を避けるため記録しない。
-         */
-        it('引数付きの new Date(...) は記録しない', () => {
-            runPredicted('setDeadline', () => {
-                new Date(1700000000000);
-            });
-            expect(getPredictionWarnings()).toEqual([]);
-        });
-        it('Math.random() を記録する', () => {
-            runPredicted('restart', () => {
-                Math.random();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'restart', api: 'Math.random()' }]);
-        });
-        it('performance.now() を記録する', () => {
-            runPredicted('tickLocal', () => {
-                performance.now();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'tickLocal', api: 'performance.now()' }]);
-        });
-        /**
-         * 静的解析が最も苦手とする経路。handler 本体に API が現れず、ヘルパー関数の中で
-         * 呼ばれていても捕まえられることを保証する (kikaidochu の setLine が実際にこの形)。
-         */
-        it('ヘルパー関数を経由した呼び出しも記録する', () => {
-            const setDeadlineViaHelper = () => Date.now() + 60000;
-            runPredicted('setLine', () => {
-                setDeadlineViaHelper();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'setLine', api: 'Date.now()' }]);
-        });
-        /** 元の API の戻り値はそのまま通す (計装で挙動を変えない)。 */
-        it('元の API の戻り値を変えない', () => {
-            let observed = 0;
-            runPredicted('noop', () => {
-                observed = Date.now();
-            });
-            expect(observed).toBeGreaterThan(0);
-        });
-    });
-    describe('重複の抑制', () => {
-        /** 同じ action で同じ API を何度呼んでも記録は 1 件。連打でログが溢れない。 */
-        it('同一 action / 同一 API は 1 件に畳む', () => {
-            runPredicted('gm.timer.set', () => {
-                Date.now();
-                Date.now();
-            });
-            runPredicted('gm.timer.set', () => {
-                Date.now();
-            });
-            expect(getPredictionWarnings()).toEqual([{ action: 'gm.timer.set', api: 'Date.now()' }]);
-        });
-        /** action が違えば別件として記録する。どの action を直すべきか分かる必要がある。 */
-        it('action が違えば別件として記録する', () => {
-            runPredicted('a', () => {
-                Date.now();
-            });
-            runPredicted('b', () => {
-                Date.now();
-            });
-            expect(getPredictionWarnings()).toEqual([
-                { action: 'a', api: 'Date.now()' },
-                { action: 'b', api: 'Date.now()' },
-            ]);
-        });
-        /** 同じ action でも API が違えば別件。両方直す必要があるため。 */
-        it('API が違えば別件として記録する', () => {
-            runPredicted('restart', () => {
-                Date.now();
-                Math.random();
-            });
-            expect(getPredictionWarnings()).toEqual([
-                { action: 'restart', api: 'Date.now()' },
-                { action: 'restart', api: 'Math.random()' },
-            ]);
-        });
-    });
-    describe('グローバルの復元', () => {
-        /** 先読みの外で呼ばれる API は計装されていない (描画ループが誤検知しない前提)。 */
-        it('実行後にグローバルが元へ戻る', () => {
-            const beforeNow = Date.now;
-            const beforeRandom = Math.random;
-            const beforeDate = Date;
-            runPredicted('a', () => {
-                Date.now();
-            });
-            expect(Date.now).toBe(beforeNow);
-            expect(Math.random).toBe(beforeRandom);
-            expect(Date).toBe(beforeDate);
-        });
-        /**
-         * handler が throw しても復元する。楽観実行は throw を握りつぶして
-         * サーバー送信だけ続ける経路があるので、ここで漏れるとグローバルが汚染されたまま残る。
-         */
-        it('handler が例外を投げてもグローバルが元へ戻る', () => {
-            const beforeNow = Date.now;
-            const beforeDate = Date;
-            expect(() => {
-                runPredicted('a', () => {
-                    Date.now();
-                    throw new Error('handler failed');
-                });
-            }).toThrow('handler failed');
-            expect(Date.now).toBe(beforeNow);
-            expect(Date).toBe(beforeDate);
-            // 例外で中断しても、そこまでに呼ばれた API は記録されている。
-            expect(getPredictionWarnings()).toEqual([{ action: 'a', api: 'Date.now()' }]);
-        });
-        /** 先読みの外の呼び出しは記録されない。描画コードの Date.now() を拾わない保証。 */
-        it('先読みの外で呼んだ API は記録しない', () => {
-            Date.now();
-            Math.random();
-            expect(getPredictionWarnings()).toEqual([]);
-        });
-    });
-    describe('本番での無効化', () => {
-        /**
-         * Flutter native ホストでは計装しない。判定基準は dev hooks の attach と同じく
-         * `window.FlutterHost` の有無。
-         */
-        it('window.FlutterHost があるときは計装せず素通しする', () => {
-            window.FlutterHost = { postMessage: () => { } };
-            const beforeNow = Date.now;
-            let ran = false;
-            runPredicted('gm.timer.set', () => {
-                Date.now();
-                ran = true;
-            });
-            expect(ran).toBe(true);
-            expect(Date.now).toBe(beforeNow);
-            expect(getPredictionWarnings()).toEqual([]);
-        });
-    });
-});

package/dist/dev-state-patch.d.ts

@@ -1,81 +0,0 @@
-/**
- * @docs
- * - 外部 automation API: docs/docs/uzu_code/sdk-guide/dev-hooks.md
- *
- * `__uzu_dev.mergeRawState` / `__uzu_dev.patchRawState` の中身。
- * scenario state を「object 階層の部分更新 (RFC 7396)」と「array 要素単体の書換
- * 含む path-based ops (RFC 6902)」で書き換えるための utility。
- */
-/**
- * RFC 7396 風 Merge Patch。
- *
- * RFC 7396 strict との差分:
- * - `null` は target 側の **削除ではなく** null をセットする (`timerEndsAt: null`
- *   のような nullable field を狙い撃ちするユースケースを優先)
- * - 値を削除したいときは {@link JsonPatchOp} の `remove` を使う
- *
- * Generic は使い手側の type を残すための shape ヒントで、ランタイム上は
- * `Record<string, unknown>` と等価。
- */
-export type JsonMergePatch<S = unknown> = Partial<{
-    [K in keyof S]: S[K] extends unknown[] ? S[K] : S[K] extends object ? JsonMergePatch<S[K]> : S[K] | null;
-}> & Record<string, unknown>;
-/**
- * RFC 6902 JSON Patch operation。
- *
- * - `add` / `replace` / `test`: `value` 必須
- * - `remove`: `value` / `from` 不要
- * - `move` / `copy`: `from` 必須 (JSON Pointer)
- * - `path` は JSON Pointer (例: `/board/1/4`、root は空文字)
- */
-export type JsonPatchOp = {
-    op: 'add';
-    path: string;
-    value: unknown;
-} | {
-    op: 'remove';
-    path: string;
-} | {
-    op: 'replace';
-    path: string;
-    value: unknown;
-} | {
-    op: 'move';
-    path: string;
-    from: string;
-} | {
-    op: 'copy';
-    path: string;
-    from: string;
-} | {
-    op: 'test';
-    path: string;
-    value: unknown;
-};
-/**
- * RFC 7396 (Merge Patch) を target に in-place 適用する。
- *
- * 規則:
- * - `undefined` は no-op (key 自体を patch から落としたのと同じ)
- * - `null` は **null をセット** (RFC 7396 strict と異なる、deletion はしない)
- * - patch が object かつ target も object → 再帰 merge
- * - patch が array → atomic replace (要素単位 merge なし、RFC 7396 spec 通り)
- * - patch が primitive → overwrite
- * - **target が array で patch が non-array object** → throw (silent な
- *   `[..., ...]` → `{ "0": ..., "1": ... }` 化を防ぐ)
- *
- * 型 mismatch (例: object → primitive) は overwrite で許可する。
- */
-export declare function applyJsonMergePatch(target: Record<string, unknown>, patch: JsonMergePatch): void;
-/**
- * RFC 6902 (JSON Patch) operations を target に in-place 適用する。
- *
- * 1 op でも失敗したら **その時点で throw** する (RFC 6902 spec: operations は
- * sequentially evaluate、失敗時の rollback は規定なし)。caller が atomic に
- * したいなら state を事前に snapshot しておく。
- *
- * root pointer (`''`) は本実装では `add` / `replace` のみ許可し、
- * doc のフィールドを丸ごと差し替える形で動く (= 結局 `setRawState` で十分な
- * ケースなので、わざわざ `patchRawState` で使うことはほぼない)。
- */
-export declare function applyJsonPatch(target: Record<string, unknown>, ops: JsonPatchOp[]): void;