omni-viewer-core 0.4.0 → 0.6.0

package/dist/parsers/toml/parse.js

@@ -2,11 +2,14 @@ import { tomlPath } from './model.js';
 export function parseTomlText(text, limits = {}) {
     const settings = typeof limits === 'number' ? { maxDepth: limits } : limits;
     const maxDepth = settings.maxDepth ?? 100, maxNodes = settings.maxNodes ?? 100_000, maxTables = settings.maxTables ?? 50_000, maxArrayLength = settings.maxArrayLength ?? 100_000;
-    const root = { kind: 'table', key: '$', path: '', raw: '', line: 1, children: [] };
+    const root = { kind: 'table', key: '$', path: '', raw: '', line: 1, range: { start: 0, end: text.length }, children: [] };
     const diagnostics = [];
     let current = root, nodeCount = 1, tableCount = 1, stopped = false;
     const tables = new Map([['', root]]);
-    const lines = logicalTomlLines(text.replace(/^\uFEFF/, ''));
+    // Offsets stay relative to the untouched `text` so ranges address the same
+    // string a host renders. A leading BOM is dropped by `trim()` instead.
+    const lines = logicalTomlLines(text);
+    const lineAt = lineIndexer(text);
     const error = (code, line) => diagnostics.push({ severity: 'error', code, messageKey: `diag.${code}`, location: `line:${line}` });
     const unquote = (value) => {
         if (value.startsWith('"""') && value.endsWith('"""')) {
@@ -34,11 +37,15 @@ export function parseTomlText(text, limits = {}) {
             return value.slice(1, -1);
         return value;
     };
-    const split = (value) => {
+    /** Split on top-level commas, reporting where each trimmed part starts so
+     * inline-table and array members can carry their own range. */
+    const split = (value, base) => {
         const out = [];
         let start = 0;
         let quote = '';
         let depth = 0;
+        const push = (from, to) => { const part = value.slice(from, to); const lead = part.length - part.trimStart().length; const trimmed = part.trim(); if (trimmed)
+            out.push({ text: trimmed, at: base + from + lead }); };
         for (let i = 0; i < value.length; i++) {
             const c = value[i];
             if (quote) {
@@ -52,16 +59,18 @@ export function parseTomlText(text, limits = {}) {
             else if (c === ']' || c === '}')
                 depth--;
             else if (c === ',' && depth === 0) {
-                out.push(value.slice(start, i).trim());
+                push(start, i);
                 start = i + 1;
             }
         }
-        out.push(value.slice(start).trim());
-        return out.filter(Boolean);
+        push(start, value.length);
+        return out;
     };
     const keyParts = (key) => splitKey(key).map(unquote);
-    const makeValue = (key, path, rawValue, line, depth) => {
+    const makeValue = (key, path, rawValue, line, depth, start) => {
         const raw = rawValue.trim();
+        const from = start + (rawValue.length - rawValue.trimStart().length);
+        const range = { start: from, end: from + raw.length };
         let kind = 'string';
         let value = unquote(raw);
         if (/^(true|false)$/.test(raw)) {
@@ -76,34 +85,37 @@ export function parseTomlText(text, limits = {}) {
             kind = 'datetime';
         else if (raw.startsWith('[') && raw.endsWith(']')) {
             kind = 'array';
-            const values = split(raw.slice(1, -1));
+            const values = split(raw.slice(1, -1), from + 1);
             if (values.length > maxArrayLength) {
                 error('toml.array-limit', line);
                 values.length = maxArrayLength;
             }
-            const children = values.map((v, i) => makeValue(String(i), `${path}[${i}]`, v, line, depth + 1));
+            const children = values.map((entry, i) => makeValue(String(i), `${path}[${i}]`, entry.text, lineAt(entry.at), depth + 1, entry.at));
             nodeCount += children.length;
-            return { kind, key, path, raw, line, children };
+            return { kind, key, path, raw, line, range, children };
         }
         else if (raw.startsWith('{') && raw.endsWith('}')) {
             kind = 'table';
             const children = [];
-            for (const pair of split(raw.slice(1, -1))) {
-                const eq = indexOfEquals(pair);
+            for (const pair of split(raw.slice(1, -1), from + 1)) {
+                const eq = indexOfEquals(pair.text);
                 if (eq < 0) {
-                    error('toml.invalid-inline-table', line);
+                    error('toml.invalid-inline-table', lineAt(pair.at));
                     continue;
                 }
-                const childKey = unquote(pair.slice(0, eq).trim());
-                children.push(makeValue(childKey, tomlPath(path, childKey), pair.slice(eq + 1), line, depth + 1));
+                const childKey = unquote(pair.text.slice(0, eq).trim());
+                const child = makeValue(childKey, tomlPath(path, childKey), pair.text.slice(eq + 1), lineAt(pair.at), depth + 1, pair.at + eq + 1);
+                child.range = { start: pair.at, end: pair.at + pair.text.length };
+                children.push(child);
             }
-            return { kind, key, path, raw, line, children };
+            return { kind, key, path, raw, line, range, children };
         }
         if (depth > maxDepth)
             error('toml.max-depth', line);
         nodeCount++;
-        return { kind, key, path, value, raw, line };
+        return { kind, key, path, value, raw, line, range };
     };
+    let pending = [];
     for (const logical of lines) {
         if (settings.signal?.aborted) {
             error('aborted', logical.line);
@@ -116,9 +128,22 @@ export function parseTomlText(text, limits = {}) {
             break;
         }
         const i = logical.line - 1;
-        const source = stripComment(logical.text).trim();
-        if (!source)
+        const uncommented = stripComment(logical.text);
+        const trailing = commentBody(logical.text.slice(uncommented.length));
+        const source = uncommented.trim();
+        // Comment runs stay attached to the next declaration; a blank line ends
+        // the run so a file-header comment never leaks onto unrelated keys.
+        if (!source) {
+            if (trailing === undefined)
+                pending = [];
+            else
+                pending.push(trailing);
             continue;
+        }
+        const comment = [...pending, ...(trailing === undefined ? [] : [trailing])].join('\n') || undefined;
+        pending = [];
+        const base = logical.offset + (logical.text.length - logical.text.trimStart().length);
+        const declaration = { start: base, end: base + source.length };
         const arrayTable = source.match(/^\[\[(.+)\]\]$/);
         const table = source.match(/^\[(.+)\]$/);
         if (arrayTable || table) {
@@ -134,12 +159,12 @@ export function parseTomlText(text, limits = {}) {
                 const parent = tables.get(parentPath) ?? root;
                 let collection = parent.children.find(node => node.key === parts.at(-1) && node.kind === 'array');
                 if (!collection) {
-                    collection = { kind: 'array', key: parts.at(-1), path, raw: '', line: i + 1, children: [] };
+                    collection = { kind: 'array', key: parts.at(-1), path, raw: '', line: i + 1, range: declaration, children: [] };
                     parent.children.push(collection);
                     nodeCount++;
                 }
                 const index = collection.children.length;
-                const node = { kind: 'table', key: String(index), path: `${path}[${index}]`, raw: '', line: i + 1, children: [] };
+                const node = { kind: 'table', key: String(index), path: `${path}[${index}]`, raw: '', line: i + 1, range: declaration, ...(comment ? { comment } : {}), children: [] };
                 collection.children.push(node);
                 tables.set(path, node);
                 current = node;
@@ -149,7 +174,7 @@ export function parseTomlText(text, limits = {}) {
             else {
                 let node = tables.get(path);
                 if (!node) {
-                    node = { kind: 'table', key: parts.at(-1), path, raw: '', line: i + 1, children: [] };
+                    node = { kind: 'table', key: parts.at(-1), path, raw: '', line: i + 1, range: declaration, ...(comment ? { comment } : {}), children: [] };
                     (tables.get(parts.slice(0, -1).join('.')) ?? root).children.push(node);
                     tables.set(path, node);
                     nodeCount++;
@@ -175,7 +200,7 @@ export function parseTomlText(text, limits = {}) {
         for (const part of parts.slice(0, -1)) {
             let nested = parent.children.find(n => n.key === part && n.kind === 'table');
             if (!nested) {
-                nested = { kind: 'table', key: part, path: tomlPath(parent.path, part), raw: '', line: i + 1, children: [] };
+                nested = { kind: 'table', key: part, path: tomlPath(parent.path, part), raw: '', line: i + 1, range: declaration, children: [] };
                 parent.children.push(nested);
             }
             parent = nested;
@@ -183,25 +208,45 @@ export function parseTomlText(text, limits = {}) {
         const key = parts.at(-1);
         if (parent.children.some(n => n.key === key))
             error('toml.duplicate-key', i + 1);
-        else
-            parent.children.push(makeValue(key, tomlPath(parent.path, key), source.slice(eq + 1), i + 1, 0));
+        else {
+            const node = makeValue(key, tomlPath(parent.path, key), source.slice(eq + 1), i + 1, 0, base + eq + 1);
+            // The declaration reads better than the bare value when a host turns
+            // the range into a selection, so widen it to cover `key = value`.
+            node.range = declaration;
+            if (comment)
+                node.comment = comment;
+            parent.children.push(node);
+        }
     }
     return { document: { text, root }, diagnostics };
 }
 /** Group physical lines while a multiline string or a composite array/table
  * remains open. This preserves the declaration line for diagnostics. */
 function logicalTomlLines(text) {
-    const physical = text.split(/\r\n|\n|\r/);
+    const physical = [];
+    {
+        const separator = /\r\n|\n|\r/g;
+        let last = 0;
+        let match;
+        while ((match = separator.exec(text))) {
+            physical.push({ text: text.slice(last, match.index), offset: last });
+            last = match.index + match[0].length;
+        }
+        physical.push({ text: text.slice(last), offset: last });
+    }
     const out = [];
-    let buffer = '';
+    let open = false;
     let start = 1;
+    let offset = 0;
     let triple = '';
     let depth = 0;
     for (let i = 0; i < physical.length; i++) {
-        const line = physical[i] ?? '';
-        if (!buffer)
+        const { text: line, offset: at } = physical[i];
+        if (!open) {
+            open = true;
             start = i + 1;
-        buffer += (buffer ? '\n' : '') + line;
+            offset = at;
+        }
         for (let p = 0; p < line.length; p++) {
             if (line.startsWith('"""', p) || line.startsWith("'''", p)) {
                 const token = line.slice(p, p + 3);
@@ -219,16 +264,41 @@ function logicalTomlLines(text) {
             else if (c === ']' || c === '}')
                 depth--;
         }
+        // Slicing the original text (rather than re-joining) keeps every offset
+        // inside a logical line usable as an index into `text`.
         if (!triple && depth <= 0) {
-            out.push({ line: start, text: buffer });
-            buffer = '';
+            out.push({ line: start, text: text.slice(offset, at + line.length), offset });
+            open = false;
             depth = 0;
         }
     }
-    if (buffer)
-        out.push({ line: start, text: buffer });
+    if (open)
+        out.push({ line: start, text: text.slice(offset), offset });
     return out;
 }
+/** 1-based line lookup for offsets, used by inline members that may sit on a
+ * different physical line than their declaration. */
+function lineIndexer(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '\n')
+            starts.push(i + 1);
+        else if (c === '\r') {
+            if (text[i + 1] === '\n')
+                i++;
+            starts.push(i + 1);
+        }
+    }
+    return offset => { let low = 0, high = starts.length - 1; while (low < high) {
+        const mid = (low + high + 1) >> 1;
+        if (starts[mid] <= offset)
+            low = mid;
+        else
+            high = mid - 1;
+    } return low + 1; };
+}
+function commentBody(rest) { const text = rest.trimStart(); return text.startsWith('#') ? text.slice(1).trim() : undefined; }
 function stripComment(line) { let q = ''; for (let i = 0; i < line.length; i++) {
     const c = line[i];
     if (q) {

package/dist/parsers/yaml/index.js

@@ -18,6 +18,7 @@ export function parseYaml(input, options = {}) {
         const ast = options.deps.parse(text);
         const maxDocs = options.limits?.maxDocuments ?? 100;
         const docs = [];
+        const duplicates = [];
         for (let i = 0; i < Math.min(ast.length, maxDocs); i++) {
             if (options.signal?.aborted)
                 return finish(docs.length ? { status: 'partial', document: { text, documents: docs }, diagnostics: [...diagnostics, { severity: 'warning', code: 'yaml.aborted', messageKey: 'diag.aborted' }] } : { status: 'failed', failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' }, diagnostics });
@@ -28,11 +29,13 @@ export function parseYaml(input, options = {}) {
                 diagnostics.push({ severity: 'error', code: 'yaml.invalid', messageKey: 'diag.yaml.invalid', location: pos ? `line:${pos.line}:${pos.col}` : `document:${i + 1}` });
             }
             const node = options.deps.normalize ? options.deps.normalize(sourceDoc, i) : normalizeUnknown(sourceDoc, `$doc[${i}]`);
-            const violation = validateTree(node, options.limits?.maxEntries ?? 100_000, options.limits?.maxDepth ?? 100, options.limits?.maxAliases ?? 10_000);
+            const violation = validateTree(node, options.limits?.maxEntries ?? 100_000, options.limits?.maxDepth ?? 100, options.limits?.maxAliases ?? 10_000, duplicates);
             if (violation)
                 diagnostics.push({ severity: 'warning', code: violation, messageKey: `diag.${violation}`, location: `document:${i + 1}` });
             docs.push(node);
         }
+        for (const duplicate of duplicates)
+            diagnostics.push({ severity: 'warning', code: 'yaml.duplicate-key', messageKey: 'diag.yaml.duplicate-key', args: { key: duplicate.key }, location: duplicate.path });
         if (ast.length > maxDocs)
             diagnostics.push({ severity: 'warning', code: 'yaml.document-limit', messageKey: 'diag.yaml.document-limit', args: { count: maxDocs } });
         return finish(diagnostics.length ? { status: 'partial', document: { text, documents: docs }, diagnostics } : { status: 'ok', document: { text, documents: docs }, diagnostics });
@@ -44,7 +47,8 @@ export function parseYaml(input, options = {}) {
 function normalizeUnknown(value, path, key = '$') { if (Array.isArray(value))
     return { kind: 'seq', key, path, children: value.map((v, i) => normalizeUnknown(v, `${path}[${i}]`, String(i))) }; if (value !== null && typeof value === 'object')
     return { kind: 'map', key, path, children: Object.entries(value).map(([k, v]) => normalizeUnknown(v, `${path}.${k}`, k)) }; return { kind: 'scalar', key, path, value: value, raw: String(value) }; }
-function validateTree(root, maxNodes, maxDepth, maxAliases) { let nodes = 0, aliases = 0; const stack = [{ node: root, depth: 0 }]; while (stack.length) {
+const MAX_DUPLICATE_KEY_DIAGNOSTICS = 20;
+function validateTree(root, maxNodes, maxDepth, maxAliases, duplicates) { let nodes = 0, aliases = 0; const stack = [{ node: root, depth: 0 }]; while (stack.length) {
     const item = stack.pop();
     nodes++;
     if (nodes > maxNodes)
@@ -53,6 +57,14 @@ function validateTree(root, maxNodes, maxDepth, maxAliases) { let nodes = 0, ali
         return 'yaml.depth-limit';
     if (item.node.kind === 'alias' && ++aliases > maxAliases)
         return 'yaml.alias-limit';
+    if (item.node.kind === 'map' && item.node.children) {
+        const seen = new Set();
+        for (const child of item.node.children) {
+            if (seen.has(child.key) && duplicates.length < MAX_DUPLICATE_KEY_DIAGNOSTICS && !duplicates.some(d => d.path === item.node.path && d.key === child.key))
+                duplicates.push({ path: item.node.path, key: child.key });
+            seen.add(child.key);
+        }
+    }
     for (const child of item.node.children ?? [])
         stack.push({ node: child, depth: item.depth + 1 });
 } return null; }

package/dist/parsers/yaml/self-loading.js

@@ -1,19 +1,31 @@
 /** Dynamic optional-peer loader; base parser/viewer modules never import yaml. */
 export async function loadYamlParserDeps() {
     const yaml = await import('yaml');
-    const normalize = (node, path, key = '$') => {
-        const n = node;
-        if (n.contents !== undefined)
-            return normalize(n.contents, path, key);
-        const common = { key, path, range: n.range, anchorId: n.anchor };
-        if (n.type === 'ALIAS' || n.constructor?.name === 'Alias')
-            return { ...common, kind: 'alias', aliasOf: String(n.source ?? '') };
-        if (Array.isArray(n.items)) {
-            const pairs = n.items.every(item => item && typeof item === 'object' && 'key' in item);
-            return { ...common, kind: pairs ? 'map' : 'seq', children: n.items.map((item, i) => { const pair = item; const childKey = pairs ? String(pair.key?.value ?? pair.key?.source ?? i) : String(i); return normalize(pairs ? pair.value : item, pairs ? `${path}.${childKey}` : `${path}[${i}]`, childKey); }) };
-        }
-        const value = n.value ?? node;
-        return { ...common, kind: 'scalar', value: value, raw: n.source === undefined ? String(value) : String(n.source) };
+    const normalizeDocument = (document, index) => {
+        const anchors = new Map();
+        const record = (node) => { if (node.anchorId)
+            anchors.set(node.anchorId, node); return node; };
+        const normalize = (node, path, key = '$') => {
+            const n = node;
+            if (n.contents !== undefined)
+                return normalize(n.contents, path, key);
+            const common = { key, path, range: n.range, anchorId: n.anchor };
+            if (n.type === 'ALIAS' || n.constructor?.name === 'Alias') {
+                const name = String(n.source ?? '');
+                const target = anchors.get(name);
+                if (target?.kind !== 'scalar')
+                    return { ...common, kind: 'alias', aliasOf: name, raw: `*${name}` };
+                return { ...common, kind: 'alias', aliasOf: name, value: target.value ?? null, raw: target.raw ?? `*${name}` };
+            }
+            if (Array.isArray(n.items)) {
+                const pairs = n.items.every(item => item && typeof item === 'object' && 'key' in item);
+                const seen = new Map();
+                return record({ ...common, kind: pairs ? 'map' : 'seq', children: n.items.map((item, i) => { const pair = item; const keyValue = typeof pair.key?.value === 'symbol' ? pair.key?.source ?? '<<' : pair.key?.value; const childKey = pairs ? String(keyValue ?? pair.key?.source ?? i) : String(i); const occurrence = (seen.get(childKey) ?? 0) + 1; seen.set(childKey, occurrence); return normalize(pairs ? pair.value : item, pairs ? `${path}.${childKey}${occurrence > 1 ? `#${occurrence}` : ''}` : `${path}[${i}]`, childKey); }) });
+            }
+            const value = n.value ?? node;
+            return record({ ...common, kind: 'scalar', value: value, raw: n.source === undefined ? String(value) : String(n.source) });
+        };
+        return normalize(document, `$doc[${index}]`);
     };
-    return { parse: (text) => yaml.parseAllDocuments(text, { schema: 'core', customTags: [] }), normalize: (document, index) => normalize(document, `$doc[${index}]`) };
+    return { parse: (text) => yaml.parseAllDocuments(text, { schema: 'core', customTags: [], uniqueKeys: false, merge: true }), normalize: normalizeDocument };
 }

package/dist/registry/index.d.ts

@@ -61,6 +61,7 @@ export declare const REQIF_VIEWER_DESCRIPTOR: ViewerDescriptor;
 export declare const HDF5_MAGIC_PREFIX: readonly [137, 72, 68, 70, 13, 10, 26, 10];
 export declare const HDF5_VIEWER_DESCRIPTOR: ViewerDescriptor;
 export declare const MAT_VIEWER_DESCRIPTOR: ViewerDescriptor;
+export declare const SAFETENSORS_VIEWER_DESCRIPTOR: ViewerDescriptor;
 export declare const AUDIO_VIEWER_DESCRIPTOR: ViewerDescriptor;
 export declare const VIDEO_VIEWER_DESCRIPTOR: ViewerDescriptor;
 export declare const DBC_VIEWER_DESCRIPTOR: ViewerDescriptor;

package/dist/registry/index.js

@@ -72,7 +72,7 @@ export const PDF_VIEWER_DESCRIPTOR = {
     priority: 20,
     magicPrefix: [0x25, 0x50, 0x44, 0x46, 0x2d], // '%PDF-'
     requiredServices: [],
-    optionalServices: ['save', 'writeback', 'filePick']
+    optionalServices: ['save', 'writeback', 'filePick', 'clipboard']
 };
 export const PARQUET_MAGIC_SIGNATURES = [[{ offset: 0, bytes: [0x50, 0x41, 0x52, 0x31] }]];
 export const PARQUET_VIEWER_DESCRIPTOR = { id: 'parquet', displayNameKey: 'parquet.title', extensions: ['parquet'], priority: 20, magicSignatures: PARQUET_MAGIC_SIGNATURES, requiredServices: [], optionalServices: ['clipboard', 'save'] };
@@ -87,6 +87,9 @@ export const HDF5_MAGIC_PREFIX = [0x89, 0x48, 0x44, 0x46, 0x0d, 0x0a, 0x1a, 0x0a
 // signature still enables extensionless content routing below.
 export const HDF5_VIEWER_DESCRIPTOR = { id: 'hdf5', displayNameKey: 'hdf5.title', extensions: ['h5', 'hdf5', 'he5'], priority: 20, requiredServices: [], optionalServices: ['clipboard'] };
 export const MAT_VIEWER_DESCRIPTOR = { id: 'mat', displayNameKey: 'mat.title', extensions: ['mat'], priority: 20, requiredServices: [], optionalServices: ['clipboard'] };
+// Safetensors has no fixed leading magic (the file opens with an 8-byte header
+// length), so it is admitted by extension and validated by the parser.
+export const SAFETENSORS_VIEWER_DESCRIPTOR = { id: 'safetensors', displayNameKey: 'safetensors.title', extensions: ['safetensors'], priority: 20, requiredServices: [], optionalServices: ['clipboard'] };
 export const AUDIO_VIEWER_DESCRIPTOR = { id: 'audio', displayNameKey: 'audio.title', extensions: ['mp3', 'wav', 'pcm', 'aiff', 'aif', 'aifc', 'amr', 'awb', 'ogg', 'flac', 'ac3', 'aac', 'm4a'], priority: 20, requiredServices: [], optionalServices: [] };
 export const VIDEO_VIEWER_DESCRIPTOR = { id: 'video', displayNameKey: 'video.title', extensions: ['mp4', 'mts', 'm2ts', 'avi', 'mov', 'wmv', 'flv', 'webm', 'mkv'], priority: 20, requiredServices: [], optionalServices: [] };
 export const DBC_VIEWER_DESCRIPTOR = { id: 'dbc', displayNameKey: 'dbc.title', extensions: ['dbc'], priority: 20, requiredServices: [], optionalServices: ['clipboard'] };
@@ -162,7 +165,7 @@ export const IMAGE_VIEWER_DESCRIPTOR = {
 export const MARKDOWN_VIEWER_DESCRIPTOR = {
     id: 'markdown', displayNameKey: 'markdown.title',
     extensions: ['md', 'markdown', 'mdown', 'mkdn', 'mkd'], priority: 10,
-    requiredServices: [], optionalServices: ['clipboard', 'navigation', 'documentAssets', 'writeback']
+    requiredServices: [], optionalServices: ['clipboard', 'navigation', 'documentAssets', 'writeback', 'save']
 };
 export const ARCHIVE_MAGIC_SIGNATURES = [
     [{ offset: 0, bytes: [0x50, 0x4b, 0x03, 0x04] }], [{ offset: 0, bytes: [0x50, 0x4b, 0x05, 0x06] }],
@@ -200,6 +203,7 @@ export const CORE_VIEWER_DESCRIPTORS = [
     REQIF_VIEWER_DESCRIPTOR,
     HDF5_VIEWER_DESCRIPTOR,
     MAT_VIEWER_DESCRIPTOR,
+    SAFETENSORS_VIEWER_DESCRIPTOR,
     PPT_VIEWER_DESCRIPTOR,
     WORD_VIEWER_DESCRIPTOR,
     HWP_VIEWER_DESCRIPTOR,

package/dist/styles/pdf.css

@@ -51,6 +51,14 @@
     color: var(--omni-fg-muted, #9d9d9d);
     margin-right: 8px;
 }
+.omni-pdf__save-mode {
+    padding: 2px 6px;
+    color: var(--omni-fg-muted, #9d9d9d);
+    border: 1px solid var(--omni-border, #3c3c3c);
+    border-radius: 999px;
+    font-size: 11px;
+    white-space: nowrap;
+}
 .omni-pdf__page-input {
     width: 52px;
     padding: 3px 5px;
@@ -175,6 +183,17 @@
     min-width: 56px;
     text-align: center;
 }
+.omni-pdf__thumbs-toggle {
+    width: 30px;
+    height: 28px;
+    padding: 0;
+    margin-right: auto;
+    font-size: 16px;
+    line-height: 1;
+}
+.omni-pdf__thumbs-toggle.is-collapsed {
+    opacity: 0.6;
+}
 .omni-pdf__view-menu-wrap { position: relative; }
 .omni-pdf__view-menu-btn {
     width: 30px;
@@ -219,12 +238,19 @@
     background: var(--omni-border, #3c3c3c);
 }
 .omni-pdf__body {
+    position: relative;
     flex: 1;
     min-height: 0;
     display: grid;
     grid-template-columns: 160px minmax(0, 1fr);
     overflow: hidden;
 }
+.omni-pdf__body--thumbs-collapsed {
+    grid-template-columns: minmax(0, 1fr);
+}
+.omni-pdf__body--thumbs-collapsed .omni-pdf__thumbs {
+    display: none;
+}
 .omni-pdf__thumbs {
     overflow: auto;
     min-height: 0;
@@ -265,10 +291,28 @@
 .omni-pdf__thumb.drop-before::before { top: -6px; }
 .omni-pdf__thumb.drop-after::after { bottom: -6px; }
 .omni-pdf__thumb canvas {
+    display: block;
     max-width: 100%;
     background: #ffffff;
     box-shadow: 0 1px 3px rgba(0, 0, 0, 0.5);
 }
+.omni-pdf__thumb-page {
+    position: relative;
+    max-width: 100%;
+}
+.omni-pdf__thumb-annotation {
+    position: absolute;
+    z-index: 1;
+    overflow: hidden;
+    pointer-events: none;
+    color: #111111; /* ink on paper */
+    white-space: nowrap;
+}
+.omni-pdf__thumb-annotation img { display: block; }
+.omni-pdf__thumb-annotation.omni-pdf__underline::after,
+.omni-pdf__thumb-annotation.omni-pdf__strikeout::after {
+    height: 1px;
+}
 .omni-pdf__thumb-label {
     font-family: var(--omni-font-mono, Monaco, Menlo, monospace);
     font-size: 10px;
@@ -438,6 +482,161 @@
     content: '';
     background: var(--omni-hl-color, #ffeb3b);
 }
+/* Floating action bar shown above a selected text-markup annotation. */
+.omni-pdf__markup-toolbar {
+    position: absolute;
+    z-index: 5;
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    padding: 4px;
+    transform: translateY(calc(-100% - 8px));
+    background: var(--omni-bg-secondary, #252526);
+    border: 1px solid var(--omni-border, #3c3c3c);
+    border-radius: 10px;
+    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.45);
+    cursor: default;
+}
+.omni-pdf button.omni-pdf__markup-tool {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 30px;
+    height: 30px;
+    padding: 0;
+    border: 0;
+    border-radius: 8px;
+    background: transparent;
+    color: var(--omni-fg, #e8e8e8);
+    font-size: 15px;
+    line-height: 1;
+    cursor: pointer;
+}
+.omni-pdf button.omni-pdf__markup-tool:hover:not(:disabled) { background: var(--omni-button-hover-bg, #45494e); }
+.omni-pdf button.omni-pdf__markup-tool:disabled { opacity: 0.4; cursor: default; }
+.omni-pdf__markup-color::before {
+    content: '';
+    width: 18px;
+    height: 18px;
+    border-radius: 5px;
+    background: var(--omni-hl-color, #ffeb3b);
+    border: 1px solid rgba(0, 0, 0, 0.25);
+}
+.omni-pdf__markup-color-wrap { position: relative; display: inline-flex; }
+.omni-pdf__markup-palette {
+    position: absolute;
+    top: calc(100% + 6px);
+    left: 50%;
+    transform: translateX(-50%);
+    display: none;
+    grid-template-columns: repeat(3, auto);
+    gap: 6px;
+    padding: 8px;
+    background: var(--omni-bg-secondary, #252526);
+    border: 1px solid var(--omni-border, #3c3c3c);
+    border-radius: 8px;
+    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.45);
+    z-index: 6;
+}
+.omni-pdf__markup-palette.is-open { display: grid; }
+.omni-pdf button.omni-pdf__markup-swatch,
+.omni-pdf button.omni-pdf__markup-swatch:hover:not(:disabled) {
+    width: 22px;
+    height: 22px;
+    padding: 0;
+    border-radius: 5px;
+    border: 1px solid rgba(255, 255, 255, 0.25);
+    background: var(--omni-hl-color, #ffeb3b);
+    cursor: pointer;
+}
+.omni-pdf button.omni-pdf__markup-swatch.is-current {
+    outline: 2px solid var(--omni-accent, #0e639c);
+    outline-offset: 1px;
+}
+/* Left overlay panel listing every text-markup annotation. */
+.omni-pdf__markup-list {
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    z-index: 6;
+    display: none;
+    flex-direction: column;
+    width: min(280px, 70%);
+    background: var(--omni-bg-secondary, #252526);
+    border-right: 1px solid var(--omni-border, #3c3c3c);
+    box-shadow: 2px 0 12px rgba(0, 0, 0, 0.35);
+    overflow-y: auto;
+}
+.omni-pdf__markup-list.is-open { display: flex; }
+.omni-pdf__markup-list-head {
+    position: sticky;
+    top: 0;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 12px;
+    background: var(--omni-bg-secondary, #252526);
+    border-bottom: 1px solid var(--omni-border, #3c3c3c);
+}
+.omni-pdf__markup-list-title { font-weight: 600; }
+.omni-pdf button.omni-pdf__markup-list-close {
+    width: 26px;
+    height: 26px;
+    padding: 0;
+    border: 0;
+    border-radius: 6px;
+    background: transparent;
+    color: var(--omni-fg, #e8e8e8);
+    font-size: 18px;
+    line-height: 1;
+    cursor: pointer;
+}
+.omni-pdf button.omni-pdf__markup-list-close:hover:not(:disabled) { background: var(--omni-button-hover-bg, #45494e); }
+.omni-pdf__markup-list-empty {
+    padding: 16px 12px;
+    color: var(--omni-fg-muted, #9d9d9d);
+    font-size: 13px;
+}
+.omni-pdf button.omni-pdf__markup-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    width: 100%;
+    padding: 10px 12px;
+    border: 0;
+    border-bottom: 1px solid var(--omni-border, #3c3c3c);
+    background: transparent;
+    color: var(--omni-fg, #e8e8e8);
+    text-align: left;
+    cursor: pointer;
+}
+.omni-pdf button.omni-pdf__markup-item:hover:not(:disabled) { background: var(--omni-button-hover-bg, #45494e); }
+.omni-pdf button.omni-pdf__markup-item.is-selected {
+    background: var(--omni-button-hover-bg, #45494e);
+    box-shadow: inset 3px 0 0 var(--omni-accent, #0e639c);
+}
+.omni-pdf__markup-item-dot {
+    flex: none;
+    width: 14px;
+    height: 14px;
+    border-radius: 3px;
+    border: 1px solid rgba(255, 255, 255, 0.25);
+    background: var(--omni-hl-color, #ffeb3b);
+}
+.omni-pdf__markup-item-text {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-size: 13px;
+}
+.omni-pdf__markup-item-page {
+    flex: none;
+    color: var(--omni-fg-muted, #9d9d9d);
+    font-size: 12px;
+}
 .omni-pdf__text-editor {
     position: absolute;
     z-index: 3;
@@ -543,9 +742,13 @@
         grid-template-columns: minmax(0, 1fr);
         grid-template-rows: minmax(120px, 30vh) minmax(0, 1fr);
     }
+    .omni-pdf__body--thumbs-collapsed {
+        grid-template-rows: minmax(0, 1fr);
+    }
     .omni-pdf__thumbs {
         border-right: 0;
         border-bottom: 1px solid var(--omni-border, #3c3c3c);
     }
     .omni-pdf__pages { grid-row: 2; }
+    .omni-pdf__body--thumbs-collapsed .omni-pdf__pages { grid-row: 1; }
 }