@iostore/devtools 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# @iostore/devtools
+
+IO DevTools 不是 Redux DevTools 的替代品， 而是一个 状态运行时观察系统。
+
+Commit 是“因”
+
+Diff 是“证据”
+
+Snapshot 是“历史”
+
+Derived 是“计算图”

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { IoDevtools, IoDevtoolsBridge, IoDevtoolsEvent, IoDevtoolsOptions, IoDevtoolsPerfSample, IoDevtoolsPerfSummary, IoDevtoolsState, IoHistoryEntry, IoPatchDiff, IoPatchDiffTreeNode, IoSnapshotDiff, ReduxDevToolsImportState, } from './lib/types.js';
+export { createIoDevtools } from './lib/create-io-devtools.js';
+export { diffSnapshots } from './lib/diff-snapshots.js';
+export { buildPatchDiffTree } from './lib/patch-diff-tree.js';
+export { exportReduxDevToolsImportState } from './lib/export-redux-devtools.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createIoDevtools } from './lib/create-io-devtools.js';
+export { diffSnapshots } from './lib/diff-snapshots.js';
+export { buildPatchDiffTree } from './lib/patch-diff-tree.js';
+export { exportReduxDevToolsImportState } from './lib/export-redux-devtools.js';

package/dist/lib/create-io-devtools.d.ts

@@ -0,0 +1,3 @@
+import type { IoDevtools, IoDevtoolsOptions } from './types.js';
+export declare function createIoDevtools(targetInput: unknown, options?: IoDevtoolsOptions): IoDevtools;
+//# sourceMappingURL=create-io-devtools.d.ts.map

package/dist/lib/create-io-devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-io-devtools.d.ts","sourceRoot":"","sources":["../../src/lib/create-io-devtools.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,UAAU,EAGV,iBAAiB,EAIlB,MAAM,YAAY,CAAC;AAqDpB,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,OAAO,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,UAAU,CA+OZ"}

package/dist/lib/create-io-devtools.js

@@ -0,0 +1,269 @@
+import { applyUpdate, getLinkInfo, onError, undoUpdate } from '@iostore/store';
+import { diffSnapshots } from './diff-snapshots.js';
+import { createReduxBridgeConnector } from './devtools/bridge.js';
+import { createHistoryController } from './devtools/history.js';
+import { createPerfTracker } from './devtools/perf.js';
+import { exportReduxDevToolsImportState } from './export-redux-devtools.js';
+import { sanitizeForJson } from './sanitize.js';
+function nowEpochMs() {
+    return Date.now();
+}
+function nowPerfMs() {
+    return globalThis.performance?.now
+        ? globalThis.performance.now()
+        : Date.now();
+}
+function createIdFactory(prefix) {
+    let seq = 0;
+    return () => {
+        seq += 1;
+        const rand = globalThis.crypto?.randomUUID?.();
+        return rand ? `${prefix}-${rand}` : `${prefix}-${seq}`;
+    };
+}
+function clampInt(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function asTarget(target) {
+    const t = target;
+    if (typeof t?.snapshot !== 'function' ||
+        typeof t?.subscribeUpdate !== 'function') {
+        throw new Error('createIoDevtools: target must implement snapshot() and subscribeUpdate()');
+    }
+    return target;
+}
+function patchToDiff(patch) {
+    if (patch.op === 'set')
+        return { op: 'set', path: patch.path, prev: patch.prev, next: patch.next };
+    if (patch.op === 'splice')
+        return {
+            op: 'splice',
+            path: patch.path,
+            start: patch.start,
+            deleteCount: patch.deleteCount,
+            deleted: patch.deleted,
+            items: patch.items,
+        };
+    return { op: 'sort', path: patch.path, order: patch.order };
+}
+export function createIoDevtools(targetInput, options) {
+    const target = asTarget(targetInput);
+    const createId = createIdFactory(options?.name ?? 'io');
+    let enabled = options?.enabled ?? true;
+    let paused = false;
+    const errors = [];
+    const listeners = new Set();
+    let isTimeTraveling = false;
+    const perfEnabled = options?.perf?.enabled ?? true;
+    const perfWindowSize = clampInt(options?.perf?.windowSize ?? 60, 1, 5_000);
+    const perfSampleRate = Math.max(0, Math.min(1, options?.perf?.sampleRate ?? 1));
+    const snapshotStrategy = options?.captureSnapshots ?? 'always';
+    const maxHistory = clampInt(options?.maxHistory ?? 10_000, 1, 10_000);
+    const emit = (event) => {
+        for (const listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                options?.onDevtoolsError?.(error);
+            }
+        }
+    };
+    function getState() {
+        let links;
+        try {
+            links = getLinkInfo(target);
+        }
+        catch (error) {
+            options?.onDevtoolsError?.(error);
+            links = undefined;
+        }
+        return {
+            enabled,
+            paused,
+            cursor: historyController.getCursor(),
+            history: historyController.history,
+            errors,
+            links,
+            perf: perfTracker.getState(),
+        };
+    }
+    const reportDevtoolsError = (error, source) => {
+        errors.push(error);
+        emit({ type: 'error', source, error, state: getState() });
+        options?.onDevtoolsError?.(error);
+    };
+    const perfTracker = createPerfTracker({
+        enabled: perfEnabled,
+        windowSize: perfWindowSize,
+        sampleRate: perfSampleRate,
+        emit,
+        getState,
+    });
+    const historyController = createHistoryController({
+        target,
+        options,
+        emit,
+        getState,
+        createId,
+        perfTracker,
+        snapshotStrategy,
+        maxHistory,
+        nowEpochMs,
+        nowPerfMs,
+        diffSnapshots,
+        patchToDiff,
+        sanitizeForJson,
+        exportReduxDevToolsImportState,
+    });
+    const onUpdate = (update) => {
+        if (!enabled || paused || isTimeTraveling)
+            return;
+        try {
+            historyController.appendHistory(update);
+        }
+        catch (error) {
+            reportDevtoolsError(error, 'devtools');
+        }
+    };
+    const errorHandler = (error, path, operation) => {
+        if (!enabled)
+            return;
+        errors.push(error);
+        emit({
+            type: 'error',
+            source: 'io',
+            error,
+            path,
+            operation,
+            state: getState(),
+        });
+    };
+    const unsubscribeUpdate = target.subscribeUpdate(onUpdate);
+    const unsubscribeError = onError(targetInput, errorHandler);
+    const initialSnapshot = target.snapshot();
+    historyController.setInitialSnapshot(initialSnapshot);
+    historyController.setLastSnapshot(initialSnapshot);
+    const withTimeTraveling = (fn) => {
+        isTimeTraveling = true;
+        try {
+            return fn();
+        }
+        finally {
+            isTimeTraveling = false;
+        }
+    };
+    const applyTimeTravel = (update, kind) => {
+        const from = historyController.getCursor();
+        return withTimeTraveling(() => {
+            try {
+                applyUpdate(targetInput, update, { emitUpdate: false });
+                const to = kind === 'undo' ? from - 1 : from + 1;
+                const next = clampInt(to, -1, historyController.history.length - 1);
+                historyController.setCursor(next);
+                emit({
+                    type: 'timeTravel',
+                    kind,
+                    from,
+                    to: historyController.getCursor(),
+                    state: getState(),
+                });
+                return true;
+            }
+            catch (error) {
+                reportDevtoolsError(error, 'devtools');
+                return false;
+            }
+        });
+    };
+    const undo = () => {
+        const cursor = historyController.getCursor();
+        if (cursor < 0)
+            return false;
+        const entry = historyController.history[cursor];
+        return applyTimeTravel(undoUpdate(entry.update), 'undo');
+    };
+    const redo = () => {
+        const cursor = historyController.getCursor();
+        if (cursor >= historyController.history.length - 1)
+            return false;
+        const entry = historyController.history[cursor + 1];
+        return applyTimeTravel(entry.update, 'redo');
+    };
+    const goTo = (index) => {
+        const to = clampInt(index, -1, historyController.history.length - 1);
+        const from = historyController.getCursor();
+        if (to === from)
+            return true;
+        const step = () => (historyController.getCursor() > to ? undo() : redo());
+        while (historyController.getCursor() !== to) {
+            if (!step())
+                return false;
+        }
+        emit({
+            type: 'timeTravel',
+            kind: 'goTo',
+            from,
+            to: historyController.getCursor(),
+            state: getState(),
+        });
+        return true;
+    };
+    const clear = () => {
+        const from = historyController.getCursor();
+        historyController.clearHistory();
+        emit({
+            type: 'timeTravel',
+            kind: 'clear',
+            from,
+            to: historyController.getCursor(),
+            state: getState(),
+        });
+    };
+    const connectReduxDevToolsExtension = createReduxBridgeConnector({
+        target,
+        options,
+        listeners,
+        emit,
+        getState,
+        reportDevtoolsError,
+        history: historyController.history,
+        clearHistory: historyController.clearHistory,
+        resetSnapshots: (next) => {
+            historyController.setInitialSnapshot(next);
+            historyController.setLastSnapshot(next);
+        },
+        goTo,
+        withTimeTraveling,
+        sanitizeForJson,
+    });
+    const devtools = {
+        getState,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        setEnabled: (next) => {
+            enabled = next;
+        },
+        pause: () => {
+            paused = true;
+        },
+        resume: () => {
+            paused = false;
+        },
+        destroy: () => {
+            unsubscribeUpdate();
+            unsubscribeError();
+            listeners.clear();
+        },
+        clear,
+        timeTravel: { undo, redo, goTo },
+        export: {
+            json: historyController.exportJson,
+            reduxDevToolsImport: historyController.exportReduxImport,
+        },
+        connectReduxDevToolsExtension,
+    };
+    return devtools;
+}

package/dist/lib/devtools/bridge.d.ts

@@ -0,0 +1,21 @@
+import type { IoDevtoolsBridge, IoDevtoolsEvent, IoDevtoolsOptions, IoDevtoolsState, IoDevtoolsTarget, IoHistoryEntry } from '../types.js';
+type BridgeDeps = {
+    target: IoDevtoolsTarget;
+    options?: IoDevtoolsOptions;
+    listeners: Set<(event: IoDevtoolsEvent) => void>;
+    emit: (event: IoDevtoolsEvent) => void;
+    getState: () => IoDevtoolsState;
+    reportDevtoolsError: (error: unknown, source: 'bridge') => void;
+    history: IoHistoryEntry[];
+    clearHistory: () => void;
+    resetSnapshots: (next: unknown) => void;
+    goTo: (index: number) => boolean;
+    withTimeTraveling: <T>(fn: () => T) => T;
+    sanitizeForJson: (value: unknown, options?: IoDevtoolsOptions['export']) => unknown;
+};
+export declare function createReduxBridgeConnector(deps: BridgeDeps): (bridgeOptions?: {
+    window?: unknown;
+    name?: string;
+}) => IoDevtoolsBridge | null;
+export {};
+//# sourceMappingURL=bridge.d.ts.map

package/dist/lib/devtools/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/lib/devtools/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,cAAc,EAEf,MAAM,aAAa,CAAC;AAWrB,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,SAAS,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC,CAAC;IACjD,IAAI,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,MAAM,eAAe,CAAC;IAChC,mBAAmB,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IAChE,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,cAAc,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACjC,iBAAiB,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACzC,eAAe,EAAE,CACf,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,iBAAiB,CAAC,QAAQ,CAAC,KAClC,OAAO,CAAC;CACd,CAAC;AAUF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,UAAU,IACjD,gBAAgB;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,KAAG,gBAAgB,GAAG,IAAI,CAoG5B"}

package/dist/lib/devtools/bridge.js

@@ -0,0 +1,93 @@
+function getReduxExtension(win) {
+    const w = win;
+    const ext = w?.__REDUX_DEVTOOLS_EXTENSION__;
+    if (!ext)
+        return null;
+    if (typeof ext.connect !== 'function')
+        return null;
+    return ext;
+}
+export function createReduxBridgeConnector(deps) {
+    return (bridgeOptions) => {
+        const enabledByConfig = deps.options?.reduxDevTools?.enabled ?? false;
+        if (!enabledByConfig)
+            return null;
+        const win = bridgeOptions?.window ?? globalThis;
+        const ext = getReduxExtension(win);
+        if (!ext)
+            return null;
+        const name = bridgeOptions?.name ??
+            deps.options?.reduxDevTools?.name ??
+            deps.options?.name ??
+            'IO';
+        const connection = ext.connect({ name });
+        connection.init(deps.sanitizeForJson(deps.target.snapshot(), deps.options?.export));
+        const onBridgeUpdate = (event) => {
+            if (event.type !== 'mutation')
+                return;
+            const index = deps.history.length - 1;
+            const actionType = `IO/${index + 1}`;
+            const state = deps.sanitizeForJson(deps.target.snapshot(), deps.options?.export);
+            try {
+                connection.send({ type: actionType }, state);
+            }
+            catch (error) {
+                deps.reportDevtoolsError(error, 'bridge');
+            }
+        };
+        const unsub = (() => {
+            const fn = (event) => onBridgeUpdate(event);
+            deps.listeners.add(fn);
+            return () => deps.listeners.delete(fn);
+        })();
+        const handleMessage = (message) => {
+            const m = message;
+            if (m?.type !== 'DISPATCH')
+                return;
+            const payload = m.payload;
+            const dispatchType = payload?.type;
+            if (dispatchType === 'RESET') {
+                deps.clearHistory();
+                connection.init(deps.sanitizeForJson(deps.target.snapshot(), deps.options?.export));
+                return;
+            }
+            if (dispatchType === 'COMMIT') {
+                deps.clearHistory();
+                const snapshot = deps.target.snapshot();
+                deps.resetSnapshots(snapshot);
+                connection.init(deps.sanitizeForJson(snapshot, deps.options?.export));
+                return;
+            }
+            if (dispatchType === 'JUMP_TO_ACTION' ||
+                dispatchType === 'JUMP_TO_STATE') {
+                const actionIdRaw = payload?.actionId;
+                const actionId = typeof actionIdRaw === 'number'
+                    ? actionIdRaw
+                    : typeof actionIdRaw === 'string'
+                        ? Number(actionIdRaw)
+                        : NaN;
+                if (!Number.isFinite(actionId))
+                    return;
+                const nextIndex = actionId - 1;
+                deps.withTimeTraveling(() => deps.goTo(nextIndex));
+            }
+        };
+        connection.subscribe(handleMessage);
+        deps.emit({ type: 'bridge', connected: true, state: deps.getState() });
+        const bridge = {
+            disconnect: () => {
+                try {
+                    unsub();
+                    connection.unsubscribe();
+                }
+                catch (error) {
+                    deps.reportDevtoolsError(error, 'bridge');
+                }
+                finally {
+                    deps.emit({ type: 'bridge', connected: false, state: deps.getState() });
+                }
+            },
+        };
+        return bridge;
+    };
+}

package/dist/lib/devtools/history.d.ts

@@ -0,0 +1,41 @@
+import type { IoPatch, IoUpdate } from '@iostore/store';
+import type { IoDevtoolsEvent, IoDevtoolsOptions, IoDevtoolsSnapshotStrategy, IoDevtoolsState, IoDevtoolsTarget, IoHistoryEntry, IoPatchDiff, ReduxDevToolsImportState } from '../types.js';
+import type { PerfTracker } from './perf.js';
+type HistoryDeps = {
+    target: IoDevtoolsTarget;
+    options?: IoDevtoolsOptions;
+    emit: (event: IoDevtoolsEvent) => void;
+    getState: () => IoDevtoolsState;
+    createId: () => string;
+    perfTracker: PerfTracker;
+    snapshotStrategy: IoDevtoolsSnapshotStrategy;
+    maxHistory: number;
+    nowEpochMs: () => number;
+    nowPerfMs: () => number;
+    diffSnapshots: (prev: unknown, next: unknown, options?: {
+        maxChanges?: number;
+    }) => unknown;
+    patchToDiff: (patch: IoPatch) => IoPatchDiff;
+    sanitizeForJson: (value: unknown, options?: IoDevtoolsOptions['export']) => unknown;
+    exportReduxDevToolsImportState: (args: {
+        initialState: unknown;
+        history: ReadonlyArray<IoHistoryEntry>;
+        cursor: number;
+    }) => ReduxDevToolsImportState;
+};
+export type HistoryController = {
+    history: IoHistoryEntry[];
+    getCursor: () => number;
+    setCursor: (next: number) => void;
+    getLastSnapshot: () => unknown | undefined;
+    setLastSnapshot: (next: unknown | undefined) => void;
+    getInitialSnapshot: () => unknown;
+    setInitialSnapshot: (next: unknown) => void;
+    appendHistory: (update: IoUpdate) => void;
+    clearHistory: () => void;
+    exportJson: () => string;
+    exportReduxImport: () => ReduxDevToolsImportState;
+};
+export declare function createHistoryController(deps: HistoryDeps): HistoryController;
+export {};
+//# sourceMappingURL=history.d.ts.map

package/dist/lib/devtools/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/lib/devtools/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,0BAA0B,EAC1B,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,WAAW,EAEX,wBAAwB,EACzB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,MAAM,eAAe,CAAC;IAChC,QAAQ,EAAE,MAAM,MAAM,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,0BAA0B,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,aAAa,EAAE,CACb,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAC9B,OAAO,CAAC;IACb,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,WAAW,CAAC;IAC7C,eAAe,EAAE,CACf,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,iBAAiB,CAAC,QAAQ,CAAC,KAClC,OAAO,CAAC;IACb,8BAA8B,EAAE,CAAC,IAAI,EAAE;QACrC,YAAY,EAAE,OAAO,CAAC;QACtB,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;QACvC,MAAM,EAAE,MAAM,CAAC;KAChB,KAAK,wBAAwB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,eAAe,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC;IAC3C,eAAe,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,KAAK,IAAI,CAAC;IACrD,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAClC,kBAAkB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5C,aAAa,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC1C,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;CACnD,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CA2J5E"}

package/dist/lib/devtools/history.js

@@ -0,0 +1,127 @@
+export function createHistoryController(deps) {
+    let cursor = -1;
+    let lastEpochMs = deps.nowEpochMs();
+    let lastSnapshot;
+    let initialSnapshot;
+    const history = [];
+    const maybeCaptureSnapshot = () => {
+        if (deps.snapshotStrategy === 'never')
+            return {};
+        const t0 = deps.nowPerfMs();
+        const snapshot = deps.target.snapshot();
+        const t1 = deps.nowPerfMs();
+        return { snapshot, ms: t1 - t0 };
+    };
+    const appendHistory = (update) => {
+        const epoch = deps.nowEpochMs();
+        const intervalMs = epoch - lastEpochMs;
+        lastEpochMs = epoch;
+        const t0 = deps.nowPerfMs();
+        if (cursor < history.length - 1)
+            history.splice(cursor + 1);
+        const snapshotBefore = deps.snapshotStrategy === 'always' ? lastSnapshot : undefined;
+        const beforeInfo = deps.snapshotStrategy === 'always' ? { snapshot: snapshotBefore } : undefined;
+        const afterInfo = maybeCaptureSnapshot();
+        const patches = deps.options?.filterPatch
+            ? update.patches.filter((p) => deps.options?.filterPatch?.(p, update))
+            : update.patches;
+        const patchDiffs = patches.map(deps.patchToDiff);
+        let diffMs;
+        if (deps.snapshotStrategy === 'always' &&
+            beforeInfo?.snapshot !== undefined &&
+            afterInfo.snapshot !== undefined) {
+            const d0 = deps.nowPerfMs();
+            deps.diffSnapshots(beforeInfo.snapshot, afterInfo.snapshot, {
+                maxChanges: 1,
+            });
+            const d1 = deps.nowPerfMs();
+            diffMs = d1 - d0;
+        }
+        const t1 = deps.nowPerfMs();
+        const perf = deps.perfTracker.enabled
+            ? {
+                patchCount: update.patches.length,
+                intervalMs,
+                snapshotMs: afterInfo.ms,
+                diffMs,
+                totalMs: t1 - t0,
+            }
+            : undefined;
+        const entry = {
+            id: deps.createId(),
+            timestamp: epoch,
+            update,
+            patchDiffs,
+            snapshotBefore: deps.snapshotStrategy === 'always' ? snapshotBefore : undefined,
+            snapshotAfter: deps.snapshotStrategy === 'always' ? afterInfo.snapshot : undefined,
+            perf,
+        };
+        history.push(entry);
+        while (history.length > deps.maxHistory) {
+            history.shift();
+            cursor -= 1;
+        }
+        cursor = history.length - 1;
+        lastSnapshot = entry.snapshotAfter ?? lastSnapshot;
+        if (entry.perf)
+            deps.perfTracker.record(entry.perf);
+        deps.emit({ type: 'mutation', entry, state: deps.getState() });
+    };
+    const clearHistory = () => {
+        history.length = 0;
+        cursor = -1;
+    };
+    const exportJson = () => {
+        const payload = {
+            name: deps.options?.name ?? 'IO',
+            initialSnapshot: deps.sanitizeForJson(initialSnapshot, deps.options?.export),
+            cursor,
+            history: history.map((e) => ({
+                id: e.id,
+                timestamp: e.timestamp,
+                update: e.update,
+                patchDiffs: e.patchDiffs,
+                snapshotBefore: deps.snapshotStrategy === 'always'
+                    ? deps.sanitizeForJson(e.snapshotBefore, deps.options?.export)
+                    : undefined,
+                snapshotAfter: deps.snapshotStrategy === 'always'
+                    ? deps.sanitizeForJson(e.snapshotAfter, deps.options?.export)
+                    : undefined,
+                perf: e.perf,
+            })),
+        };
+        return JSON.stringify(payload, null, 2);
+    };
+    const exportReduxImport = () => {
+        if (deps.snapshotStrategy !== 'always') {
+            throw new Error('devtools.export.reduxDevToolsImport requires captureSnapshots="always"');
+        }
+        return deps.exportReduxDevToolsImportState({
+            initialState: deps.sanitizeForJson(initialSnapshot, deps.options?.export),
+            history: history.map((e) => ({
+                ...e,
+                snapshotAfter: deps.sanitizeForJson(e.snapshotAfter, deps.options?.export),
+            })),
+            cursor,
+        });
+    };
+    return {
+        history,
+        getCursor: () => cursor,
+        setCursor: (next) => {
+            cursor = next;
+        },
+        getLastSnapshot: () => lastSnapshot,
+        setLastSnapshot: (next) => {
+            lastSnapshot = next;
+        },
+        getInitialSnapshot: () => initialSnapshot,
+        setInitialSnapshot: (next) => {
+            initialSnapshot = next;
+        },
+        appendHistory,
+        clearHistory,
+        exportJson,
+        exportReduxImport,
+    };
+}

package/dist/lib/devtools/perf.d.ts

@@ -0,0 +1,16 @@
+import type { IoDevtoolsEvent, IoDevtoolsPerfSample, IoDevtoolsState } from '../types.js';
+type PerfTrackerOptions = {
+    enabled: boolean;
+    windowSize: number;
+    sampleRate: number;
+    emit: (event: IoDevtoolsEvent) => void;
+    getState: () => IoDevtoolsState;
+};
+export type PerfTracker = {
+    enabled: boolean;
+    getState: () => IoDevtoolsState['perf'];
+    record: (sample: IoDevtoolsPerfSample) => void;
+};
+export declare function createPerfTracker(options: PerfTrackerOptions): PerfTracker;
+export {};
+//# sourceMappingURL=perf.d.ts.map

package/dist/lib/devtools/perf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf.d.ts","sourceRoot":"","sources":["../../../src/lib/devtools/perf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EAEpB,eAAe,EAChB,MAAM,aAAa,CAAC;AAErB,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,MAAM,eAAe,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,eAAe,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;CAChD,CAAC;AAsDF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAyB1E"}

package/dist/lib/devtools/perf.js

@@ -0,0 +1,73 @@
+function defaultPerfSummary(windowSize) {
+    return {
+        windowSize,
+        avgTotalMs: 0,
+        maxTotalMs: 0,
+        avgSnapshotMs: 0,
+        maxSnapshotMs: 0,
+        avgDiffMs: 0,
+        maxDiffMs: 0,
+    };
+}
+function computePerfSummary(recent, windowSize) {
+    if (recent.length === 0)
+        return defaultPerfSummary(windowSize);
+    let totalSum = 0;
+    let totalMax = 0;
+    let snapSum = 0;
+    let snapMax = 0;
+    let diffSum = 0;
+    let diffMax = 0;
+    let snapCount = 0;
+    let diffCount = 0;
+    for (const s of recent) {
+        totalSum += s.totalMs;
+        totalMax = Math.max(totalMax, s.totalMs);
+        if (typeof s.snapshotMs === 'number') {
+            snapSum += s.snapshotMs;
+            snapMax = Math.max(snapMax, s.snapshotMs);
+            snapCount += 1;
+        }
+        if (typeof s.diffMs === 'number') {
+            diffSum += s.diffMs;
+            diffMax = Math.max(diffMax, s.diffMs);
+            diffCount += 1;
+        }
+    }
+    return {
+        windowSize,
+        avgTotalMs: totalSum / recent.length,
+        maxTotalMs: totalMax,
+        avgSnapshotMs: snapCount ? snapSum / snapCount : undefined,
+        maxSnapshotMs: snapCount ? snapMax : undefined,
+        avgDiffMs: diffCount ? diffSum / diffCount : undefined,
+        maxDiffMs: diffCount ? diffMax : undefined,
+    };
+}
+export function createPerfTracker(options) {
+    const perfRecent = [];
+    const getPerfState = () => {
+        if (!options.enabled)
+            return undefined;
+        return {
+            recent: perfRecent,
+            summary: computePerfSummary(perfRecent, options.windowSize),
+        };
+    };
+    const record = (sample) => {
+        if (!options.enabled)
+            return;
+        if (options.sampleRate < 1 && Math.random() > options.sampleRate)
+            return;
+        perfRecent.push(sample);
+        while (perfRecent.length > options.windowSize)
+            perfRecent.shift();
+        const summary = computePerfSummary(perfRecent, options.windowSize);
+        options.emit({ type: 'perf', sample, summary, state: options.getState() });
+    };
+    return {
+        enabled: options.enabled,
+        getState: getPerfState,
+        record,
+    };
+}

package/dist/lib/diff-snapshots.d.ts

@@ -0,0 +1,9 @@
+import type { IoSnapshotDiff } from './types.js';
+type DiffOptions = {
+    maxDepth?: number;
+    maxChanges?: number;
+    maxArrayLength?: number;
+};
+export declare function diffSnapshots(prev: unknown, next: unknown, options?: DiffOptions): IoSnapshotDiff[];
+export {};
+//# sourceMappingURL=diff-snapshots.d.ts.map

package/dist/lib/diff-snapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-snapshots.d.ts","sourceRoot":"","sources":["../../src/lib/diff-snapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,KAAK,WAAW,GAAG;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAYF,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE,WAAW,GACpB,cAAc,EAAE,CAqClB"}

package/dist/lib/diff-snapshots.js

@@ -0,0 +1,46 @@
+const defaultOptions = {
+    maxDepth: 6,
+    maxChanges: 500,
+    maxArrayLength: 200,
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function diffSnapshots(prev, next, options) {
+    const o = { ...defaultOptions, ...(options ?? {}) };
+    const diffs = [];
+    const visit = (path, a, b, depth) => {
+        if (diffs.length >= o.maxChanges)
+            return;
+        if (Object.is(a, b))
+            return;
+        if (depth >= o.maxDepth) {
+            diffs.push({ path, prev: a, next: b });
+            return;
+        }
+        if (Array.isArray(a) && Array.isArray(b)) {
+            const len = Math.max(a.length, b.length);
+            const capped = Math.min(len, o.maxArrayLength);
+            for (let i = 0; i < capped; i += 1) {
+                visit([...path, i], a[i], b[i], depth + 1);
+                if (diffs.length >= o.maxChanges)
+                    return;
+            }
+            if (len !== capped)
+                diffs.push({ path, prev: a, next: b });
+            return;
+        }
+        if (isRecord(a) && isRecord(b)) {
+            const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+            for (const key of keys) {
+                visit([...path, key], a[key], b[key], depth + 1);
+                if (diffs.length >= o.maxChanges)
+                    return;
+            }
+            return;
+        }
+        diffs.push({ path, prev: a, next: b });
+    };
+    visit([], prev, next, 0);
+    return diffs;
+}

package/dist/lib/export-redux-devtools.d.ts

@@ -0,0 +1,7 @@
+import type { IoHistoryEntry, ReduxDevToolsImportState } from './types.js';
+export declare function exportReduxDevToolsImportState(args: {
+    initialState: unknown;
+    history: ReadonlyArray<IoHistoryEntry>;
+    cursor: number;
+}): ReduxDevToolsImportState;
+//# sourceMappingURL=export-redux-devtools.d.ts.map

package/dist/lib/export-redux-devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-redux-devtools.d.ts","sourceRoot":"","sources":["../../src/lib/export-redux-devtools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAEd,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAgBpB,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,wBAAwB,CA6B3B"}

package/dist/lib/export-redux-devtools.js

@@ -0,0 +1,41 @@
+function formatPath(path) {
+    if (path.length === 0)
+        return '$';
+    return '$.' + path.map((s) => (typeof s === 'number' ? `[${s}]` : String(s))).join('.');
+}
+function summarizeEntry(entry) {
+    const first = entry.patchDiffs[0];
+    if (!first)
+        return 'IO_UPDATE';
+    if (first.op === 'set')
+        return `IO_SET ${formatPath(first.path)}`;
+    if (first.op === 'splice')
+        return `IO_SPLICE ${formatPath(first.path)}`;
+    if (first.op === 'sort')
+        return `IO_SORT ${formatPath(first.path)}`;
+    return 'IO_UPDATE';
+}
+export function exportReduxDevToolsImportState(args) {
+    const actionsById = {
+        '0': { type: '@@IO/INIT' },
+    };
+    const computedStates = [{ state: args.initialState }];
+    for (let i = 0; i < args.history.length; i += 1) {
+        const entry = args.history[i];
+        const actionId = String(i + 1);
+        actionsById[actionId] = { type: summarizeEntry(entry) };
+        computedStates.push({ state: entry.snapshotAfter });
+    }
+    const stagedActionIds = new Array(args.history.length + 1);
+    for (let i = 0; i < stagedActionIds.length; i += 1)
+        stagedActionIds[i] = i;
+    const currentStateIndex = Math.max(0, Math.min(computedStates.length - 1, args.cursor + 1));
+    return {
+        actionsById,
+        computedStates,
+        currentStateIndex,
+        nextActionId: args.history.length + 1,
+        skippedActionIds: [],
+        stagedActionIds,
+    };
+}

package/dist/lib/patch-diff-tree.d.ts

@@ -0,0 +1,3 @@
+import type { IoPatchDiff, IoPatchDiffTreeNode } from './types.js';
+export declare function buildPatchDiffTree(patches: ReadonlyArray<IoPatchDiff>): IoPatchDiffTreeNode[];
+//# sourceMappingURL=patch-diff-tree.d.ts.map

package/dist/lib/patch-diff-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch-diff-tree.d.ts","sourceRoot":"","sources":["../../src/lib/patch-diff-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAanE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,GAClC,mBAAmB,EAAE,CA+BvB"}

package/dist/lib/patch-diff-tree.js

@@ -0,0 +1,39 @@
+function ensureChild(parent, key, path) {
+    if (!parent.childrenMap)
+        parent.childrenMap = new Map();
+    const existing = parent.childrenMap.get(key);
+    if (existing)
+        return existing;
+    const next = { key, path };
+    parent.childrenMap.set(key, next);
+    return next;
+}
+export function buildPatchDiffTree(patches) {
+    const root = { key: '$', path: [] };
+    for (const patch of patches) {
+        let node = root;
+        const path = patch.path ?? [];
+        for (let i = 0; i < path.length; i += 1) {
+            const segment = path[i];
+            node = ensureChild(node, segment, path.slice(0, i + 1));
+        }
+        if (!node.patches)
+            node.patches = [];
+        node.patches.push(patch);
+    }
+    const toPublic = (n) => {
+        const children = n.childrenMap
+            ? Array.from(n.childrenMap.values()).map(toPublic)
+            : undefined;
+        return {
+            key: n.key,
+            path: n.path,
+            children: children && children.length > 0 ? children : undefined,
+            patches: n.patches && n.patches.length > 0 ? n.patches : undefined,
+        };
+    };
+    const result = root.childrenMap
+        ? Array.from(root.childrenMap.values()).map(toPublic)
+        : [];
+    return result;
+}

package/dist/lib/sanitize.d.ts

@@ -0,0 +1,3 @@
+import type { IoDevtoolsExportOptions } from './types.js';
+export declare function sanitizeForJson(value: unknown, options?: IoDevtoolsExportOptions): unknown;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/lib/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/lib/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAqB1D,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CA4C1F"}

package/dist/lib/sanitize.js

@@ -0,0 +1,70 @@
+const defaultOptions = {
+    maxDepth: 8,
+    maxArrayLength: 200,
+    maxStringLength: 10_000,
+    redact: (_path, value) => value,
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function clampString(value, max) {
+    if (value.length <= max)
+        return value;
+    return value.slice(0, max) + `…(${value.length - max} more)`;
+}
+export function sanitizeForJson(value, options) {
+    const o = { ...defaultOptions, ...(options ?? {}) };
+    const walk = (path, v, depth) => {
+        const redacted = o.redact(path, v);
+        if (depth >= o.maxDepth)
+            return '[MaxDepth]';
+        if (redacted === null)
+            return null;
+        if (redacted === undefined)
+            return undefined;
+        if (typeof redacted === 'string')
+            return clampString(redacted, o.maxStringLength);
+        if (typeof redacted === 'number')
+            return Number.isFinite(redacted) ? redacted : String(redacted);
+        if (typeof redacted === 'boolean')
+            return redacted;
+        if (typeof redacted === 'bigint')
+            return redacted.toString();
+        if (typeof redacted === 'symbol')
+            return redacted.toString();
+        if (typeof redacted === 'function')
+            return '[Function]';
+        if (redacted instanceof Date)
+            return redacted.toISOString();
+        if (redacted instanceof Error) {
+            return {
+                name: redacted.name,
+                message: redacted.message,
+                stack: redacted.stack,
+            };
+        }
+        if (Array.isArray(redacted)) {
+            const out = [];
+            const capped = Math.min(redacted.length, o.maxArrayLength);
+            for (let i = 0; i < capped; i += 1)
+                out.push(walk([...path, i], redacted[i], depth + 1));
+            if (redacted.length > capped)
+                out.push(`[+${redacted.length - capped} more items]`);
+            return out;
+        }
+        if (isRecord(redacted)) {
+            const out = {};
+            for (const [k, child] of Object.entries(redacted)) {
+                out[k] = walk([...path, k], child, depth + 1);
+            }
+            return out;
+        }
+        try {
+            return JSON.parse(JSON.stringify(redacted));
+        }
+        catch {
+            return String(redacted);
+        }
+    };
+    return walk([], value, 0);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,165 @@
+import type { IoLinkInfo, IoMutationOp, IoPatch, IoUpdate } from '@iostore/store';
+export type Unsubscribe = () => void;
+export type IoPath = IoPatch['path'];
+export type IoErrorHandler = (error: unknown, path: IoPath, operation: IoMutationOp) => void;
+export type IoDevtoolsTarget = {
+    snapshot: () => unknown;
+    subscribeUpdate: (fn: (u: IoUpdate) => void) => Unsubscribe;
+};
+export type IoDevtoolsSnapshotStrategy = 'never' | 'always';
+export type IoDevtoolsPerfOptions = {
+    enabled?: boolean;
+    sampleRate?: number;
+    windowSize?: number;
+};
+export type IoDevtoolsReduxBridgeOptions = {
+    enabled?: boolean;
+    name?: string;
+};
+export type IoDevtoolsExportOptions = {
+    maxDepth?: number;
+    maxArrayLength?: number;
+    maxStringLength?: number;
+    redact?: (path: IoPath, value: unknown) => unknown;
+};
+export type IoDevtoolsOptions = {
+    name?: string;
+    enabled?: boolean;
+    maxHistory?: number;
+    captureSnapshots?: IoDevtoolsSnapshotStrategy;
+    perf?: IoDevtoolsPerfOptions;
+    export?: IoDevtoolsExportOptions;
+    reduxDevTools?: IoDevtoolsReduxBridgeOptions;
+    filterPatch?: (patch: IoPatch, update: IoUpdate) => boolean;
+    onDevtoolsError?: (error: unknown) => void;
+};
+export type IoDevtoolsPerfSample = {
+    patchCount: number;
+    intervalMs?: number;
+    snapshotMs?: number;
+    diffMs?: number;
+    totalMs: number;
+};
+export type IoDevtoolsPerfSummary = {
+    windowSize: number;
+    avgTotalMs: number;
+    maxTotalMs: number;
+    avgSnapshotMs?: number;
+    maxSnapshotMs?: number;
+    avgDiffMs?: number;
+    maxDiffMs?: number;
+};
+export type IoPatchDiff = {
+    op: 'set';
+    path: IoPath;
+    prev: unknown;
+    next: unknown;
+} | {
+    op: 'splice';
+    path: IoPath;
+    start: number;
+    deleteCount: number;
+    deleted: ReadonlyArray<unknown>;
+    items: ReadonlyArray<unknown>;
+} | {
+    op: 'sort';
+    path: IoPath;
+    order: ReadonlyArray<number>;
+};
+export type IoSnapshotDiff = {
+    path: IoPath;
+    prev: unknown;
+    next: unknown;
+};
+export type IoPatchDiffTreeNode = {
+    key: PropertyKey;
+    path: IoPath;
+    children?: IoPatchDiffTreeNode[];
+    patches?: IoPatchDiff[];
+};
+export type IoHistoryEntry = {
+    id: string;
+    timestamp: number;
+    update: IoUpdate;
+    patchDiffs: IoPatchDiff[];
+    snapshotBefore?: unknown;
+    snapshotAfter?: unknown;
+    perf?: IoDevtoolsPerfSample;
+};
+export type IoDevtoolsState = {
+    enabled: boolean;
+    paused: boolean;
+    cursor: number;
+    history: ReadonlyArray<IoHistoryEntry>;
+    errors: ReadonlyArray<unknown>;
+    links?: IoLinkInfo;
+    perf?: {
+        recent: ReadonlyArray<IoDevtoolsPerfSample>;
+        summary: IoDevtoolsPerfSummary;
+    };
+};
+export type IoDevtoolsEvent = {
+    type: 'mutation';
+    entry: IoHistoryEntry;
+    state: IoDevtoolsState;
+} | {
+    type: 'error';
+    source: 'io' | 'devtools' | 'bridge';
+    error: unknown;
+    path?: IoPath;
+    operation?: IoMutationOp;
+    state: IoDevtoolsState;
+} | {
+    type: 'timeTravel';
+    kind: 'undo' | 'redo' | 'goTo' | 'clear';
+    from: number;
+    to: number;
+    state: IoDevtoolsState;
+} | {
+    type: 'perf';
+    sample: IoDevtoolsPerfSample;
+    summary: IoDevtoolsPerfSummary;
+    state: IoDevtoolsState;
+} | {
+    type: 'bridge';
+    connected: boolean;
+    state: IoDevtoolsState;
+};
+export type IoDevtoolsBridge = {
+    disconnect: () => void;
+};
+export type IoDevtools = {
+    getState: () => IoDevtoolsState;
+    subscribe: (listener: (event: IoDevtoolsEvent) => void) => Unsubscribe;
+    setEnabled: (enabled: boolean) => void;
+    pause: () => void;
+    resume: () => void;
+    destroy: () => void;
+    clear: () => void;
+    timeTravel: {
+        undo: () => boolean;
+        redo: () => boolean;
+        goTo: (index: number) => boolean;
+    };
+    export: {
+        json: () => string;
+        reduxDevToolsImport: () => ReduxDevToolsImportState;
+    };
+    connectReduxDevToolsExtension: (options?: {
+        window?: unknown;
+        name?: string;
+    }) => IoDevtoolsBridge | null;
+};
+export type ReduxDevToolsImportState = {
+    actionsById: Record<string, {
+        type: string;
+    }>;
+    computedStates: Array<{
+        state: unknown;
+    }>;
+    currentStateIndex: number;
+    nextActionId: number;
+    skippedActionIds: number[];
+    stagedActionIds: number[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/types.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@iostore/devtools",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@iostore/store": "*"
+  },
+  "devDependencies": {
+    "@iostore/store": "*"
+  },
+  "nx": {
+    "tags": [
+      "scope:io-devtools"
+    ],
+    "targets": {
+      "coverage": {
+        "executor": "nx:run-commands",
+        "cache": false,
+        "outputs": [
+          "{projectRoot}/test-output/vitest/coverage"
+        ],
+        "options": {
+          "cwd": "packages/io-devtools",
+          "command": "vitest run --coverage"
+        }
+      }
+    }
+  }
+}