omni-viewer-core 0.1.0

package/dist/viewers/image/limits.d.ts

@@ -0,0 +1,18 @@
+export interface ImageLimits {
+    /** Bytes; enforced before any decoder touches the input. */
+    maxInputBytes: number;
+    /** Decoded preview pixel cap (safe downscale territory). */
+    maxDecodedPixels: number;
+    /** Editable/export canvas pixel cap — beyond it editing/export disable. */
+    maxCanvasPixels: number;
+    /** Per-axis canvas dimension cap (browser canvas ceiling). */
+    maxCanvasDimension: number;
+    /** Undo history depth. */
+    maxUndoEntries: number;
+    /** Undo history byte budget. */
+    maxUndoBytes: number;
+}
+export declare const IMAGE_LIMITS: ImageLimits;
+/** Whether an image of this size can back an editable/exportable canvas
+ *  (image.md §4): both the pixel count and each axis must be within budget. */
+export declare function canvasEditable(width: number, height: number, limits?: ImageLimits): boolean;

package/dist/viewers/image/limits.js

@@ -0,0 +1,20 @@
+// Image viewer default limits (docs/viewers/image.md §4, I6). These are the
+// *image-viewer* defaults — intentionally lower than core DEFAULT_LIMITS
+// (256 MiB) because decoded pixel buffers (width × height × 4) dwarf the file
+// size. Adapters keep any stricter existing limit and may override the rest,
+// recording the value + memory measurement in their smoke.
+export const IMAGE_LIMITS = {
+    maxInputBytes: 100 * 1024 * 1024, // 100 MiB
+    maxDecodedPixels: 64 * 1_000_000, // 64 MP
+    maxCanvasPixels: 32 * 1_000_000, // 32 MP
+    maxCanvasDimension: 16_384,
+    maxUndoEntries: 100,
+    maxUndoBytes: 16 * 1024 * 1024 // 16 MiB
+};
+/** Whether an image of this size can back an editable/exportable canvas
+ *  (image.md §4): both the pixel count and each axis must be within budget. */
+export function canvasEditable(width, height, limits = IMAGE_LIMITS) {
+    return (width * height <= limits.maxCanvasPixels &&
+        width <= limits.maxCanvasDimension &&
+        height <= limits.maxCanvasDimension);
+}

package/dist/viewers/image/styles.d.ts

@@ -0,0 +1 @@
+export declare const imageViewerCss = "\n/* Reverse-contamination guard (DESIGN.md \u00A76): scoped mode neutralizes host\n   element styles; custom properties still pierce. Shadow mode: harmless. */\n.omni-viewer--image {\n    all: initial;\n}\n.omni-viewer--image :where(button, select, option, input, label, canvas, img) {\n    all: revert;\n}\n\n:host, .omni-viewer--image {\n    display: block;\n    height: 100%;\n    box-sizing: border-box;\n    color: var(--omni-fg, #d4d4d4);\n    background: var(--omni-bg, #1e1e1e);\n    font-family: var(--omni-font, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, sans-serif);\n    font-size: var(--omni-font-size, 13px);\n}\n.omni-image {\n    display: flex;\n    flex-direction: column;\n    height: 100%;\n    min-height: 0;\n}\n.omni-image__toolbar {\n    display: flex;\n    align-items: center;\n    flex-wrap: wrap;\n    gap: 6px;\n    padding: 6px 8px;\n    border-bottom: 1px solid var(--omni-border, #333);\n}\n.omni-image__toolbar button,\n.omni-image__toolbar select {\n    background: var(--omni-button-bg, #2a2a2a);\n    color: inherit;\n    border: 1px solid var(--omni-border, #444);\n    border-radius: 4px;\n    padding: 3px 8px;\n    cursor: pointer;\n}\n.omni-image__toolbar button[aria-pressed=\"true\"] {\n    background: var(--omni-accent, #0e639c);\n    border-color: var(--omni-accent, #0e639c);\n}\n.omni-image__toolbar button:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n}\n.omni-image__spacer { flex: 1; }\n.omni-image__meta { opacity: 0.8; font-variant-numeric: tabular-nums; }\n.omni-image__diagnostics {\n    padding: 4px 8px;\n    border-bottom: 1px solid var(--omni-border, #333);\n    display: flex;\n    flex-direction: column;\n    gap: 2px;\n}\n.omni-image__diag-error { color: var(--omni-error, #f14c4c); }\n\n/* Scrollable stage; checkerboard shows transparency (image.md \u00A75). */\n.omni-image__stage {\n    position: relative;\n    flex: 1;\n    min-height: 0;\n    overflow: auto;\n    display: grid;\n    place-items: center;\n    background-color: var(--omni-bg, #1e1e1e);\n    background-image:\n        linear-gradient(45deg, var(--omni-checker, #2a2a2a) 25%, transparent 25%),\n        linear-gradient(-45deg, var(--omni-checker, #2a2a2a) 25%, transparent 25%),\n        linear-gradient(45deg, transparent 75%, var(--omni-checker, #2a2a2a) 75%),\n        linear-gradient(-45deg, transparent 75%, var(--omni-checker, #2a2a2a) 75%);\n    background-size: 20px 20px;\n    background-position: 0 0, 0 10px, 10px -10px, -10px 0;\n}\n.omni-image__canvas-wrap {\n    position: relative;\n    line-height: 0;\n    transform-origin: center center;\n}\n.omni-image__canvas-wrap canvas,\n.omni-image__canvas-wrap img {\n    display: block;\n    max-width: none;\n}\n.omni-image__overlay {\n    position: absolute;\n    inset: 0;\n    outline: none;\n}\n.omni-image__aria-live {\n    position: absolute;\n    width: 1px; height: 1px;\n    overflow: hidden;\n    clip: rect(0 0 0 0);\n    white-space: nowrap;\n}\n.omni-image__empty {\n    padding: 16px;\n    opacity: 0.8;\n}\n.omni-image__toast {\n    position: absolute;\n    left: 50%;\n    bottom: 16px;\n    transform: translateX(-50%);\n    background: var(--omni-toast-bg, #333);\n    color: var(--omni-fg, #d4d4d4);\n    padding: 6px 12px;\n    border-radius: 4px;\n    box-shadow: 0 2px 8px rgba(0,0,0,0.4);\n}\n";

package/dist/viewers/image/styles.js

@@ -0,0 +1,119 @@
+// Image viewer stylesheet (DESIGN.md §6). Single source: the build emits
+// dist/styles/image.css and the renderer injects this constant into the shadow
+// root. Only --omni-* tokens (with fallbacks) — never platform variables.
+export const imageViewerCss = `
+/* Reverse-contamination guard (DESIGN.md §6): scoped mode neutralizes host
+   element styles; custom properties still pierce. Shadow mode: harmless. */
+.omni-viewer--image {
+    all: initial;
+}
+.omni-viewer--image :where(button, select, option, input, label, canvas, img) {
+    all: revert;
+}
+
+:host, .omni-viewer--image {
+    display: block;
+    height: 100%;
+    box-sizing: border-box;
+    color: var(--omni-fg, #d4d4d4);
+    background: var(--omni-bg, #1e1e1e);
+    font-family: var(--omni-font, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif);
+    font-size: var(--omni-font-size, 13px);
+}
+.omni-image {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    min-height: 0;
+}
+.omni-image__toolbar {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 6px;
+    padding: 6px 8px;
+    border-bottom: 1px solid var(--omni-border, #333);
+}
+.omni-image__toolbar button,
+.omni-image__toolbar select {
+    background: var(--omni-button-bg, #2a2a2a);
+    color: inherit;
+    border: 1px solid var(--omni-border, #444);
+    border-radius: 4px;
+    padding: 3px 8px;
+    cursor: pointer;
+}
+.omni-image__toolbar button[aria-pressed="true"] {
+    background: var(--omni-accent, #0e639c);
+    border-color: var(--omni-accent, #0e639c);
+}
+.omni-image__toolbar button:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+.omni-image__spacer { flex: 1; }
+.omni-image__meta { opacity: 0.8; font-variant-numeric: tabular-nums; }
+.omni-image__diagnostics {
+    padding: 4px 8px;
+    border-bottom: 1px solid var(--omni-border, #333);
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+.omni-image__diag-error { color: var(--omni-error, #f14c4c); }
+
+/* Scrollable stage; checkerboard shows transparency (image.md §5). */
+.omni-image__stage {
+    position: relative;
+    flex: 1;
+    min-height: 0;
+    overflow: auto;
+    display: grid;
+    place-items: center;
+    background-color: var(--omni-bg, #1e1e1e);
+    background-image:
+        linear-gradient(45deg, var(--omni-checker, #2a2a2a) 25%, transparent 25%),
+        linear-gradient(-45deg, var(--omni-checker, #2a2a2a) 25%, transparent 25%),
+        linear-gradient(45deg, transparent 75%, var(--omni-checker, #2a2a2a) 75%),
+        linear-gradient(-45deg, transparent 75%, var(--omni-checker, #2a2a2a) 75%);
+    background-size: 20px 20px;
+    background-position: 0 0, 0 10px, 10px -10px, -10px 0;
+}
+.omni-image__canvas-wrap {
+    position: relative;
+    line-height: 0;
+    transform-origin: center center;
+}
+.omni-image__canvas-wrap canvas,
+.omni-image__canvas-wrap img {
+    display: block;
+    max-width: none;
+}
+.omni-image__overlay {
+    position: absolute;
+    inset: 0;
+    outline: none;
+}
+.omni-image__aria-live {
+    position: absolute;
+    width: 1px; height: 1px;
+    overflow: hidden;
+    clip: rect(0 0 0 0);
+    white-space: nowrap;
+}
+.omni-image__empty {
+    padding: 16px;
+    opacity: 0.8;
+}
+.omni-image__toast {
+    position: absolute;
+    left: 50%;
+    bottom: 16px;
+    transform: translateX(-50%);
+    background: var(--omni-toast-bg, #333);
+    color: var(--omni-fg, #d4d4d4);
+    padding: 6px 12px;
+    border-radius: 4px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.4);
+}
+`;

package/dist/viewers/json/controller.d.ts

@@ -0,0 +1,89 @@
+import type { Diagnostic, ParseFailure } from '../../parsers/types.js';
+import { type JsonNode, type JsonParseOptions, type JsonValueKind } from '../../parsers/json/index.js';
+export type JsonViewMode = 'tree' | 'source';
+export type JsonSourceForm = 'verbatim' | 'pretty' | 'minified';
+export type JsonToolAction = 'pretty' | 'minify' | 'sort-keys' | 'validate' | 'to-csv' | 'to-xml' | 'to-yaml' | 'escape' | 'unescape' | 'base64-encode' | 'base64-decode';
+export interface JsonStatusMessage {
+    key: string;
+    args?: Record<string, string | number>;
+}
+export interface JsonToolResult {
+    action: JsonToolAction;
+    titleKey: string;
+    output: string;
+    error?: JsonStatusMessage;
+}
+export type JsonAction = {
+    type: 'set-view-mode';
+    mode: JsonViewMode;
+} | {
+    type: 'set-source-form';
+    form: JsonSourceForm;
+} | {
+    type: 'toggle-node';
+    id: string;
+} | {
+    type: 'expand-all';
+} | {
+    type: 'collapse-all';
+} | {
+    type: 'set-search';
+    search: string;
+} | {
+    type: 'next-match';
+} | {
+    type: 'prev-match';
+} | {
+    type: 'run-tool';
+    action: JsonToolAction;
+} | {
+    type: 'apply-result-to-editor';
+} | {
+    type: 'dismiss-result';
+} | {
+    type: 'edit-scratchpad';
+    text: string;
+};
+export interface JsonStatistics {
+    total: number;
+    maxDepth: number;
+    counts: Record<JsonValueKind, number>;
+}
+export interface JsonViewState {
+    status: 'ok' | 'partial' | 'failed';
+    viewMode: JsonViewMode;
+    sourceForm: JsonSourceForm;
+    root: JsonNode | null;
+    expanded: ReadonlySet<string>;
+    search: string;
+    matchCount: number;
+    currentMatch: number;
+    scratchpad: string;
+    toolResult: JsonToolResult | null;
+    statusMessage: JsonStatusMessage | null;
+    statistics: JsonStatistics | null;
+    diagnostics: Diagnostic[];
+    failure: ParseFailure | null;
+}
+export interface JsonController {
+    readonly state: JsonViewState;
+    dispatch(action: JsonAction): void;
+    subscribe(listener: (state: JsonViewState) => void): () => void;
+    /** Verbatim source (J14) — the current editable text, valid or not (J20). */
+    verbatimText(): string;
+    /** The text for the active source form (verbatim / pretty / minified). */
+    sourceText(): string;
+    /** Stable id of a node, used for toggle/copy/match addressing (P1b). */
+    nodeId(node: JsonNode): string | undefined;
+    /** JSONPath of a node by id (copy Path, J16). */
+    nodePath(id: string): string;
+    /** Copyable value of a node by id (copy Value, J16). */
+    nodeValue(id: string): string;
+    /** Ordered matching node ids (conformance kit — DOM-free). */
+    readonly matches: readonly string[];
+}
+export interface JsonControllerOptions {
+    limits?: JsonParseOptions['limits'];
+    maxDepth?: number;
+}
+export declare function createJsonController(input: Uint8Array | string, options?: JsonControllerOptions): JsonController;

package/dist/viewers/json/controller.js

@@ -0,0 +1,411 @@
+// JSON behavior controller (DESIGN.md §3-②) — DOM-free interaction state for
+// the JSON viewer. The DOM renderer is one consumer; the conformance kit drives
+// this directly (docs/viewers/json.md 부록 A). Decisions: default view = source
+// (J9), source has three forms (J14), toolbox routing = vscode (J11/부록 B-1),
+// search over key/path/type/value (J16). Toolbox transforms live in
+// transforms.ts (부록 B).
+import { decodeUtf8 } from '../../parsers/types.js';
+import { parseJson } from '../../parsers/json/index.js';
+import { base64Decode, base64Encode, escapeText, jsonToCsv, jsonToXml, jsonToYaml, serialize, toPlainValue, unescapeText } from './transforms.js';
+const TOOL_MESSAGE = {
+    pretty: 'json.tool.formatted',
+    minify: 'json.tool.minified',
+    'sort-keys': 'json.tool.sorted',
+    escape: 'json.tool.escaped',
+    unescape: 'json.tool.unescaped',
+    'base64-encode': 'json.tool.base64Encoded',
+    'base64-decode': 'json.tool.base64Decoded'
+};
+const CONVERTER_TITLE = {
+    'to-csv': 'json.tool.csvOutput',
+    'to-xml': 'json.tool.xmlOutput',
+    'to-yaml': 'json.tool.yamlOutput'
+};
+const TRANSFORM_ERROR = {
+    'invalid-unicode': 'json.tool.unescapeFailed',
+    'invalid-hex': 'json.tool.unescapeFailed',
+    trailing: 'json.tool.unescapeFailed',
+    'invalid-base64': 'json.tool.base64Failed',
+    'csv-requires-objects': 'json.tool.csvRequiresObjects'
+};
+export function createJsonController(input, options = {}) {
+    const listeners = new Set();
+    // Fallback verbatim text so a failed parse still shows the source (J20).
+    const decodedInput = typeof input === 'string' ? input : decodeUtf8(input);
+    // Nodes are addressed by a unique id, not by JSONPath: duplicate object
+    // keys share a path (e.g. both '$.a' in {"a":1,"a":2}) but must be toggled,
+    // searched, and copied independently (P1b). The id equals the path when
+    // unique and gets a '#n' suffix for duplicates, so the common case stays
+    // path-readable while duplicates stay addressable.
+    let nodeById = new Map();
+    let idOf = new WeakMap();
+    let parentIdOf = new Map();
+    let order = [];
+    let matchList = [];
+    /** Re-parse `text` and rebuild the derived indices; returns core fields. */
+    const analyze = (text) => {
+        const parseOptions = {};
+        if (options.limits !== undefined)
+            parseOptions.limits = options.limits;
+        if (options.maxDepth !== undefined)
+            parseOptions.maxDepth = options.maxDepth;
+        const { result } = parseJson(text, parseOptions);
+        nodeById = new Map();
+        idOf = new WeakMap();
+        parentIdOf = new Map();
+        order = [];
+        let root = null;
+        let statistics = null;
+        if (result.status !== 'failed') {
+            root = result.document.root;
+            const counts = {
+                object: 0,
+                array: 0,
+                string: 0,
+                number: 0,
+                boolean: 0,
+                null: 0
+            };
+            let total = 0;
+            let maxDepth = 0;
+            const walk = (node, parentId) => {
+                let id = node.path;
+                if (nodeById.has(id)) {
+                    let n = 2;
+                    while (nodeById.has(`${node.path}#${n}`))
+                        n++;
+                    id = `${node.path}#${n}`;
+                }
+                nodeById.set(id, node);
+                idOf.set(node, id);
+                parentIdOf.set(id, parentId);
+                order.push(id);
+                total++;
+                counts[node.kind]++;
+                if (node.depth > maxDepth)
+                    maxDepth = node.depth;
+                for (const child of node.children ?? [])
+                    walk(child, id);
+            };
+            walk(root, null);
+            statistics = { total, maxDepth, counts };
+        }
+        return {
+            status: result.status,
+            root,
+            statistics,
+            diagnostics: result.diagnostics,
+            failure: result.status === 'failed' ? result.failure : null
+        };
+    };
+    /** Container node ids at depth < 2 (J9 initial expand: depth 0 and 1). */
+    const initialExpanded = () => {
+        const set = new Set();
+        for (const id of order) {
+            const node = nodeById.get(id);
+            if ((node.kind === 'object' || node.kind === 'array') && node.depth < 2) {
+                set.add(id);
+            }
+        }
+        return set;
+    };
+    const isContainer = (node) => node.kind === 'object' || node.kind === 'array';
+    const searchableText = (node) => {
+        let valueText = '';
+        if (node.kind === 'string')
+            valueText = typeof node.value === 'string' ? node.value : '';
+        else if (node.kind === 'number')
+            valueText = node.rawNumber ?? '';
+        else if (node.kind === 'boolean')
+            valueText = String(node.value);
+        else if (node.kind === 'null')
+            valueText = 'null';
+        return `${node.key} ${node.path} ${node.kind} ${valueText}`.toLowerCase();
+    };
+    const recomputeMatches = (query) => {
+        matchList = [];
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return;
+        for (const id of order) {
+            if (searchableText(nodeById.get(id)).includes(q))
+                matchList.push(id);
+        }
+    };
+    /** Expand every ancestor container of the current matches (chrome). */
+    const expandMatchAncestors = (expanded) => {
+        for (const id of matchList) {
+            let parent = parentIdOf.get(id) ?? null;
+            while (parent) {
+                expanded.add(parent);
+                parent = parentIdOf.get(parent) ?? null;
+            }
+        }
+    };
+    const initial = analyze(decodedInput);
+    const state = {
+        status: initial.status,
+        viewMode: 'tree', // Preview defaults to the navigable tree.
+        sourceForm: 'pretty', // J14 (vscode text = re-serialized pretty)
+        root: initial.root,
+        expanded: initialExpanded(),
+        search: '',
+        matchCount: 0,
+        currentMatch: -1,
+        scratchpad: decodedInput,
+        toolResult: null,
+        statusMessage: null,
+        statistics: initial.statistics,
+        diagnostics: initial.diagnostics,
+        failure: initial.failure
+    };
+    const notify = () => {
+        for (const listener of listeners)
+            listener(state);
+    };
+    /** Apply a fresh scratchpad text: re-parse, refresh derived state. */
+    const setScratchpad = (text) => {
+        const next = analyze(text);
+        state.scratchpad = text;
+        state.status = next.status;
+        state.root = next.root;
+        state.statistics = next.statistics;
+        state.diagnostics = next.diagnostics;
+        state.failure = next.failure;
+        // The tree changed (edit/transform) and node ids are regenerated, so
+        // apply the initial expand rule to the new tree rather than carrying
+        // over stale ids — new depth-1 containers get expanded (P2a).
+        recomputeMatches(state.search);
+        state.matchCount = matchList.length;
+        state.currentMatch = matchList.length ? 0 : -1;
+        const expanded = initialExpanded();
+        expandMatchAncestors(expanded);
+        state.expanded = expanded;
+    };
+    const replaceScratchpad = (text, messageKey) => {
+        setScratchpad(text);
+        state.statusMessage = { key: messageKey };
+    };
+    const requireValidRoot = () => state.status === 'ok' && state.root ? state.root : null;
+    /** Show raw-text conversions for review without overwriting the editor. */
+    const runRawResult = (action, result) => {
+        const transformed = typeof result === 'string' ? { ok: true, output: result } : result;
+        state.toolResult = {
+            action,
+            titleKey: TOOL_MESSAGE[action],
+            output: transformed.ok ? transformed.output : '',
+            ...(transformed.ok
+                ? {}
+                : { error: { key: TRANSFORM_ERROR[transformed.error] ?? 'json.tool.failed' } })
+        };
+    };
+    /** Chain Base64 operations through their latest successful result while
+     * leaving the editor's original JSON untouched. */
+    const base64Input = () => {
+        const previous = state.toolResult;
+        return previous
+            && !previous.error
+            && (previous.action === 'base64-encode' || previous.action === 'base64-decode')
+            ? previous.output
+            : state.scratchpad;
+    };
+    const runConverter = (action, convert) => {
+        const root = requireValidRoot();
+        if (!root) {
+            state.toolResult = {
+                action,
+                titleKey: CONVERTER_TITLE[action],
+                output: '',
+                error: { key: 'json.tool.invalid' }
+            };
+            return;
+        }
+        const result = convert(toPlainValue(root));
+        state.toolResult = {
+            action,
+            titleKey: CONVERTER_TITLE[action],
+            output: result.ok ? result.output : '',
+            ...(result.ok ? {} : { error: { key: TRANSFORM_ERROR[result.error] ?? 'json.tool.failed' } })
+        };
+    };
+    const runTool = (action) => {
+        state.statusMessage = null;
+        switch (action) {
+            case 'pretty': {
+                const root = requireValidRoot();
+                if (root)
+                    replaceScratchpad(serialize(root, true), TOOL_MESSAGE.pretty);
+                else
+                    state.statusMessage = { key: 'json.tool.invalid' };
+                break;
+            }
+            case 'minify': {
+                const root = requireValidRoot();
+                if (root)
+                    replaceScratchpad(serialize(root, false), TOOL_MESSAGE.minify);
+                else
+                    state.statusMessage = { key: 'json.tool.invalid' };
+                break;
+            }
+            case 'sort-keys': {
+                const root = requireValidRoot();
+                if (root)
+                    replaceScratchpad(serialize(root, true, true), TOOL_MESSAGE['sort-keys']);
+                else
+                    state.statusMessage = { key: 'json.tool.invalid' };
+                break;
+            }
+            case 'validate': {
+                const root = requireValidRoot();
+                if (root) {
+                    const summary = root.kind === 'array'
+                        ? `Array(${root.children?.length ?? 0})`
+                        : root.kind;
+                    state.statusMessage = { key: 'json.tool.valid', args: { summary } };
+                }
+                else {
+                    state.statusMessage = { key: 'json.tool.invalid' };
+                }
+                break;
+            }
+            case 'escape':
+                runRawResult('escape', escapeText(state.scratchpad));
+                break;
+            case 'unescape':
+                runRawResult('unescape', unescapeText(state.scratchpad));
+                break;
+            case 'base64-encode':
+                runRawResult('base64-encode', base64Encode(base64Input()));
+                break;
+            case 'base64-decode':
+                runRawResult('base64-decode', base64Decode(base64Input()));
+                break;
+            case 'to-csv':
+                runConverter('to-csv', jsonToCsv);
+                break;
+            case 'to-xml':
+                runConverter('to-xml', jsonToXml);
+                break;
+            case 'to-yaml':
+                runConverter('to-yaml', (v) => jsonToYaml(v));
+                break;
+        }
+    };
+    const dispatch = (action) => {
+        switch (action.type) {
+            case 'set-view-mode':
+                state.viewMode = action.mode;
+                break;
+            case 'set-source-form':
+                state.sourceForm = action.form;
+                break;
+            case 'toggle-node': {
+                const node = nodeById.get(action.id);
+                if (!node || !isContainer(node))
+                    return;
+                const expanded = new Set(state.expanded);
+                if (expanded.has(action.id))
+                    expanded.delete(action.id);
+                else
+                    expanded.add(action.id);
+                state.expanded = expanded;
+                break;
+            }
+            case 'expand-all': {
+                const expanded = new Set();
+                for (const id of order) {
+                    if (isContainer(nodeById.get(id)))
+                        expanded.add(id);
+                }
+                state.expanded = expanded;
+                break;
+            }
+            case 'collapse-all':
+                state.expanded =
+                    state.root && isContainer(state.root) && order.length
+                        ? new Set([order[0]])
+                        : new Set();
+                break;
+            case 'set-search': {
+                state.search = action.search;
+                recomputeMatches(action.search);
+                state.matchCount = matchList.length;
+                state.currentMatch = matchList.length ? 0 : -1;
+                const expanded = new Set(state.expanded);
+                expandMatchAncestors(expanded);
+                state.expanded = expanded;
+                break;
+            }
+            case 'next-match':
+                if (matchList.length) {
+                    state.currentMatch = (state.currentMatch + 1) % matchList.length;
+                }
+                break;
+            case 'prev-match':
+                if (matchList.length) {
+                    state.currentMatch =
+                        (state.currentMatch - 1 + matchList.length) % matchList.length;
+                }
+                break;
+            case 'run-tool':
+                runTool(action.action);
+                break;
+            case 'apply-result-to-editor':
+                if (state.toolResult && !state.toolResult.error) {
+                    setScratchpad(state.toolResult.output);
+                    state.toolResult = null;
+                    state.statusMessage = { key: 'json.tool.applied' };
+                }
+                break;
+            case 'dismiss-result':
+                state.toolResult = null;
+                break;
+            case 'edit-scratchpad':
+                setScratchpad(action.text);
+                state.statusMessage = null;
+                break;
+        }
+        notify();
+    };
+    const nodeValue = (id) => {
+        const node = nodeById.get(id);
+        if (!node)
+            return '';
+        if (isContainer(node))
+            return serialize(node, true);
+        if (node.kind === 'string')
+            return typeof node.value === 'string' ? node.value : '';
+        if (node.kind === 'number')
+            return node.rawNumber ?? '';
+        if (node.kind === 'boolean')
+            return String(node.value);
+        return 'null';
+    };
+    const sourceText = () => {
+        if (state.sourceForm === 'verbatim')
+            return state.scratchpad;
+        if (state.root && state.status === 'ok') {
+            return serialize(state.root, state.sourceForm === 'pretty');
+        }
+        // Can't re-serialize invalid JSON — show the verbatim text instead.
+        return state.scratchpad;
+    };
+    return {
+        get state() {
+            return state;
+        },
+        dispatch,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        verbatimText: () => state.scratchpad,
+        sourceText,
+        nodeId: (node) => idOf.get(node),
+        nodePath: (id) => nodeById.get(id)?.path ?? id,
+        nodeValue,
+        get matches() {
+            return matchList;
+        }
+    };
+}