@owomark/view 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,23 +1,3 @@
-import {
-  Callout,
-  CodeDemo,
-  DEFAULT_MDX_COMPONENTS,
-  FileTree,
-  Kbd,
-  Step,
-  Steps,
-  THEME_DARK_CLASS,
-  THEME_LIGHT_CLASS,
-  Tab,
-  Tabs,
-  createOwoMarkProcessor,
-  getOwoMarkPlugins,
-  getThemeClassName,
-  rehypeMathDisplayFix,
-  rehypeSideAnnotation,
-  remarkConvertSoftBreaksToHardBreaks,
-  remarkSideAnnotation
-} from "./chunk-DHRAXGIK.js";
 import {
   BlockLayoutMap
 } from "./chunk-3CKPBCIP.js";
@@ -27,10 +7,12 @@ import {
 import {
   FALLBACK_BLOCK_HEIGHT,
   estimateBlockHeight
-} from "./chunk-Y72HQJQI.js";
+} from "./chunk-KHKPOH74.js";
 import {
-  VirtualViewportManager
-} from "./chunk-F3LG7AML.js";
+  VirtualViewportManager,
+  createSkeletonHtml,
+  ensureSkeletonStyles
+} from "./chunk-WA6XHBZS.js";
 
 // src/editor.ts
 import { createDomAdapter } from "@owomark/core/internal/dom-adapter";
@@ -829,17 +811,60 @@ var PreviewDomPatcher = class {
 };
 
 // src/renderer/registry.ts
+var DEFAULT_HEAVY_KINDS = [
+  { kind: "mermaid", meta: { mode: "html-worker-safe", priority: "deferred", heavy: true } },
+  { kind: "katex", meta: { mode: "html-worker-safe", priority: "deferred", heavy: true } },
+  { kind: "math-block", meta: { mode: "html-worker-safe", priority: "deferred", heavy: true } },
+  { kind: "chart", meta: { mode: "html-worker-safe", priority: "deferred", heavy: true } },
+  { kind: "embed", meta: { mode: "html-worker-safe", priority: "deferred", heavy: true } }
+];
 function createRendererRegistry() {
   const renderers = /* @__PURE__ */ new Map();
+  const metadata = /* @__PURE__ */ new Map();
+  for (const { kind, meta } of DEFAULT_HEAVY_KINDS) {
+    metadata.set(kind, meta);
+  }
   return {
     get(kind) {
       return renderers.get(kind) ?? null;
     },
     register(kind, renderer) {
       renderers.set(kind, renderer);
+      if (!metadata.has(kind)) {
+        metadata.set(kind, {
+          mode: renderer.mode,
+          priority: renderer.priority
+        });
+      }
     },
     unregister(kind) {
       renderers.delete(kind);
+    },
+    registerMetadata(kind, meta) {
+      metadata.set(kind, meta);
+    },
+    isHeavy(kind) {
+      const meta = metadata.get(kind);
+      if (meta?.heavy) return true;
+      const def = renderers.get(kind);
+      return def?.priority === "deferred" || false;
+    },
+    getMode(kind) {
+      const def = renderers.get(kind);
+      if (def) return def.mode;
+      return metadata.get(kind)?.mode ?? null;
+    },
+    getPriority(kind) {
+      const def = renderers.get(kind);
+      if (def) return def.priority;
+      return metadata.get(kind)?.priority ?? null;
+    },
+    listRegistered() {
+      const kinds = /* @__PURE__ */ new Set([
+        ...renderers.keys(),
+        ...metadata.keys()
+      ]);
+      return Array.from(kinds);
     }
   };
 }
@@ -948,7 +973,7 @@ function isDeferred(block, registry) {
   const def = registry.get(block.kind);
   return def?.priority === "deferred";
 }
-function createRenderBlockFull(registry, renderCache, externalRenderBlock) {
+function createRenderBlockFull(registry, renderCache, externalRenderBlock, scheduler) {
   return async function renderBlockFull(block, baseContext) {
     const context = {
       ...baseContext,
@@ -956,6 +981,14 @@ function createRenderBlockFull(registry, renderCache, externalRenderBlock) {
     };
     const customRenderer = registry.get(block.kind);
     if (customRenderer) {
+      if (customRenderer.mode === "html-worker-safe" && customRenderer.workerModuleUrl && scheduler) {
+        try {
+          const html2 = await scheduler.submitWorkerTask(block, customRenderer, context);
+          renderCache.set(block.renderKey, html2);
+          return { kind: "html", html: html2 };
+        } catch {
+        }
+      }
       const result = await customRenderer.render(block, context);
       if (result.kind === "html") {
         renderCache.set(block.renderKey, result.html);
@@ -982,6 +1015,7 @@ function createIncrementalEngine(options) {
   const themeKey = options?.themeKey ?? "";
   const viewportFirst = options?.viewportFirst ?? false;
   const registry = options?.registry ?? createRendererRegistry();
+  const scheduler = options?.scheduler;
   const externalRenderBlock = options?.renderBlock;
   const onContentUpdate = options?.onContentUpdate;
   const patcher = new PreviewDomPatcher();
@@ -992,7 +1026,7 @@ function createIncrementalEngine(options) {
   let pendingAbort = null;
   let pendingIdleIds = [];
   let pendingBackfill = /* @__PURE__ */ new Set();
-  const renderBlockFull = createRenderBlockFull(registry, renderCache, externalRenderBlock);
+  const renderBlockFull = createRenderBlockFull(registry, renderCache, externalRenderBlock, scheduler);
   function applyResult(blockId, result) {
     if (result.kind === "html") {
       patcher.patchBlockHtml(blockId, result.html);
@@ -1038,12 +1072,14 @@ function createIncrementalEngine(options) {
   return {
     mount(root) {
       patcher.mount(root);
+      ensureSkeletonStyles(root.ownerDocument);
       mounted = true;
     },
     destroy() {
       pendingAbort?.abort();
       pendingAbort = null;
       cancelAllIdle(pendingIdleIds);
+      scheduler?.release();
       patcher.destroy();
       renderCache.clear();
       pendingBackfill.clear();
@@ -1121,18 +1157,26 @@ function createIncrementalEngine(options) {
       }
     }
     if (signal.aborted) return;
+    pendingBackfill = /* @__PURE__ */ new Set();
+    for (const block of realtimeOffscreen) {
+      const height = estimateBlockHeight(block, registry);
+      htmlMap.set(block.blockId, createSkeletonHtml({ height }));
+      pendingBackfill.add(block.blockId);
+    }
+    for (const block of deferredAll) {
+      const height = estimateBlockHeight(block, registry);
+      htmlMap.set(block.blockId, createSkeletonHtml({ height }));
+      pendingBackfill.add(block.blockId);
+    }
     patcher.fullRender(blocks, htmlMap);
     for (const { blockId, result } of domMounts) {
       if (signal.aborted) return;
       applyResult(blockId, result);
     }
-    pendingBackfill = /* @__PURE__ */ new Set();
     for (const block of realtimeOffscreen) {
-      pendingBackfill.add(block.blockId);
       scheduleBlockRender(block, baseContext, signal, state.version);
     }
     for (const block of deferredAll) {
-      pendingBackfill.add(block.blockId);
       scheduleBlockRender(block, baseContext, signal, state.version);
     }
   }
@@ -1249,6 +1293,7 @@ var OffscreenMeasurer = class {
 function createVirtualEngine(options) {
   const themeKey = options?.themeKey ?? "";
   const registry = options?.registry ?? createRendererRegistry();
+  const scheduler = options?.scheduler;
   const externalRenderBlock = options?.renderBlock;
   const onContentUpdate = options?.onContentUpdate;
   const layoutMap = new BlockLayoutMap();
@@ -1256,7 +1301,7 @@ function createVirtualEngine(options) {
   const measurer = new OffscreenMeasurer();
   const viewport = new VirtualViewportManager();
   const renderCache = /* @__PURE__ */ new Map();
-  const renderBlockFull = createRenderBlockFull(registry, renderCache, externalRenderBlock);
+  const renderBlockFull = createRenderBlockFull(registry, renderCache, externalRenderBlock, scheduler);
   let renderedVersion = 0;
   let lastBlocks = [];
   let blockMap = /* @__PURE__ */ new Map();
@@ -1273,7 +1318,7 @@ function createVirtualEngine(options) {
   function getInitialHeight(block) {
     const cached = heightCache.get(block.renderKey);
     if (cached !== void 0) return cached;
-    return estimateBlockHeight(block);
+    return estimateBlockHeight(block, registry);
   }
   async function renderAndMountBlock(block, baseContext, signal) {
     if (signal.aborted) return;
@@ -1385,7 +1430,7 @@ function createVirtualEngine(options) {
       heightCache.clear();
       layoutMap.invalidateAll((blockId) => {
         const block = blockMap.get(blockId);
-        return block ? estimateBlockHeight(block) : FALLBACK_BLOCK_HEIGHT;
+        return block ? estimateBlockHeight(block, registry) : FALLBACK_BLOCK_HEIGHT;
       });
       return true;
     }
@@ -1420,6 +1465,7 @@ function createVirtualEngine(options) {
       blockResizeObserver?.disconnect();
       blockResizeObserver = null;
       observedWrappers.clear();
+      scheduler?.release();
       viewport.destroy();
       measurer.destroy();
       renderCache.clear();
@@ -1545,11 +1591,185 @@ function createOwoMarkPreviewEngine(options) {
       return createIncrementalEngine(options);
     case "virtual":
       return createVirtualEngine(options);
+    case "mdx":
+      throw new Error(
+        'The "mdx" strategy is implemented by @owomark/react OwoMarkPreview, not by @owomark/view createOwoMarkPreviewEngine().'
+      );
     default:
       throw new Error(`Unknown preview strategy: ${strategy}`);
   }
 }
 
+// src/worker/preview-task-scheduler.ts
+var MAX_CONSECUTIVE_CRASHES = 3;
+var CRASH_WINDOW_MS = 3e4;
+function serializeBlock(block) {
+  return {
+    kind: block.kind,
+    raw: block.raw,
+    blockId: block.blockId,
+    renderKey: block.renderKey,
+    startLine: block.startLine,
+    endLine: block.endLine
+  };
+}
+function createPreviewTaskScheduler(options) {
+  const poolSize = options?.poolSize ?? Math.max(1, (typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 4 : 4) - 1);
+  let refCount = 1;
+  let taskCounter = 0;
+  let permanentlyFailed = false;
+  const crashTimestamps = [];
+  const pendingTasks = /* @__PURE__ */ new Map();
+  const workers = [];
+  let nextWorkerIndex = 0;
+  function createWorkerSlot() {
+    try {
+      if (typeof Worker === "undefined") return null;
+      const worker = new Worker(
+        new URL("./preview-render.worker.js", import.meta.url),
+        { type: "module" }
+      );
+      const slot = { worker, pendingCount: 0, dead: false };
+      worker.onmessage = (e) => {
+        const resp = e.data;
+        slot.pendingCount--;
+        const pending = pendingTasks.get(resp.taskId);
+        if (!pending) return;
+        pendingTasks.delete(resp.taskId);
+        if (resp.ok) {
+          pending.resolve(resp.html);
+        } else {
+          pending.reject(new Error(resp.error));
+        }
+      };
+      worker.onerror = () => {
+        slot.dead = true;
+        slot.pendingCount = 0;
+        worker.terminate();
+        recordCrash();
+        options?.onCrash?.();
+      };
+      return slot;
+    } catch {
+      return null;
+    }
+  }
+  function recordCrash() {
+    const now = Date.now();
+    crashTimestamps.push(now);
+    while (crashTimestamps.length > 0 && now - crashTimestamps[0] > CRASH_WINDOW_MS) {
+      crashTimestamps.shift();
+    }
+    if (crashTimestamps.length >= MAX_CONSECUTIVE_CRASHES) {
+      permanentlyFailed = true;
+      terminateAll();
+    }
+  }
+  function getLeastBusySlot() {
+    if (permanentlyFailed) return null;
+    let best = null;
+    for (const slot of workers) {
+      if (slot.dead) continue;
+      if (!best || slot.pendingCount < best.pendingCount) {
+        best = slot;
+      }
+    }
+    if (best) return best;
+    if (workers.length < poolSize) {
+      const slot = createWorkerSlot();
+      if (slot) {
+        workers.push(slot);
+        return slot;
+      }
+    }
+    for (let i = 0; i < workers.length; i++) {
+      if (workers[i].dead) {
+        const slot = createWorkerSlot();
+        if (slot) {
+          workers[i] = slot;
+          return slot;
+        }
+      }
+    }
+    return null;
+  }
+  function terminateAll() {
+    for (const slot of workers) {
+      if (!slot.dead) {
+        slot.dead = true;
+        slot.worker.terminate();
+      }
+    }
+    workers.length = 0;
+    for (const [, pending] of pendingTasks) {
+      pending.reject(new Error("Scheduler terminated"));
+    }
+    pendingTasks.clear();
+  }
+  const scheduler = {
+    submitWorkerTask(block, rendererDef, context) {
+      if (permanentlyFailed || !rendererDef.workerModuleUrl) {
+        return Promise.reject(new Error("Worker unavailable"));
+      }
+      const slot = getLeastBusySlot();
+      if (!slot) {
+        return Promise.reject(new Error("No worker available"));
+      }
+      const taskId = ++taskCounter;
+      return new Promise((resolve, reject) => {
+        pendingTasks.set(taskId, { resolve, reject });
+        slot.pendingCount++;
+        slot.worker.postMessage({
+          type: "render",
+          taskId,
+          block: serializeBlock(block),
+          rendererModuleUrl: rendererDef.workerModuleUrl,
+          context: {
+            version: context.version,
+            themeKey: context.themeKey,
+            sourceLineOffset: context.sourceLineOffset
+          }
+        });
+      });
+    },
+    cancel(taskId) {
+      const pending = pendingTasks.get(taskId);
+      if (pending) {
+        pendingTasks.delete(taskId);
+        pending.reject(new Error("Task cancelled"));
+      }
+      const msg = { type: "cancel", taskId };
+      for (const slot of workers) {
+        if (!slot.dead) slot.worker.postMessage(msg);
+      }
+    },
+    cancelAll() {
+      for (const [, pending] of pendingTasks) {
+        pending.reject(new Error("All tasks cancelled"));
+      }
+      pendingTasks.clear();
+      const msg = { type: "cancel-all" };
+      for (const slot of workers) {
+        if (!slot.dead) {
+          slot.pendingCount = 0;
+          slot.worker.postMessage(msg);
+        }
+      }
+    },
+    acquire() {
+      refCount++;
+      return scheduler;
+    },
+    release() {
+      if (--refCount <= 0) {
+        refCount = 0;
+        terminateAll();
+      }
+    }
+  };
+  return scheduler;
+}
+
 // src/dom/side-annotation-positioner.ts
 var SideAnnotationPositioner = class {
   container;
@@ -1639,31 +1859,33 @@ var SideAnnotationPositioner = class {
     }
   }
 };
+
+// src/theme.ts
+var THEME_LIGHT_CLASS = "owo-theme-light";
+var THEME_DARK_CLASS = "owo-theme-dark";
+function getThemeClassName(theme) {
+  switch (theme) {
+    case "light":
+      return THEME_LIGHT_CLASS;
+    case "dark":
+      return THEME_DARK_CLASS;
+    default:
+      return theme;
+  }
+}
 export {
-  Callout,
-  CodeDemo,
-  DEFAULT_MDX_COMPONENTS,
-  FileTree,
-  Kbd,
   PreviewDomPatcher,
   SideAnnotationPositioner,
-  Step,
-  Steps,
   THEME_DARK_CLASS,
   THEME_LIGHT_CLASS,
-  Tab,
-  Tabs,
   createOwoMarkPreviewEngine,
-  createOwoMarkProcessor,
   createOwoMarkVanillaEditor,
   createOwoMarkView,
+  createPreviewTaskScheduler,
   createRendererRegistry,
+  createSkeletonHtml,
   createViewEngine,
-  getOwoMarkPlugins,
+  ensureSkeletonStyles,
   getThemeClassName,
-  rehypeMathDisplayFix,
-  rehypeSideAnnotation,
-  remarkConvertSoftBreaksToHardBreaks,
-  remarkSideAnnotation,
   renderBlockDefault
 };

package/dist/internal/virtual/height-estimator.d.ts

@@ -1,13 +1,6 @@
 import { PreviewBlock } from '@owomark/core';
+import { P as PreviewRendererRegistry } from '../../types-DsL_4tUb.js';
 
-/**
- * Heuristic height estimation for blocks before measurement.
- *
- * Uses block kind and source line count to produce a rough height estimate.
- * These estimates are used as initial placeholder heights in the coordinate
- * table until real measurement completes.
- */
-
-declare function estimateBlockHeight(block: PreviewBlock): number;
+declare function estimateBlockHeight(block: PreviewBlock, registry?: PreviewRendererRegistry): number;
 
 export { estimateBlockHeight };

package/dist/internal/virtual/height-estimator.js

@@ -1,6 +1,6 @@
 import {
   estimateBlockHeight
-} from "../../chunk-Y72HQJQI.js";
+} from "../../chunk-KHKPOH74.js";
 export {
   estimateBlockHeight
 };

package/dist/internal/virtual/viewport-manager.js

@@ -1,6 +1,6 @@
 import {
   VirtualViewportManager
-} from "../../chunk-F3LG7AML.js";
+} from "../../chunk-WA6XHBZS.js";
 export {
   VirtualViewportManager
 };

package/dist/types-DsL_4tUb.d.ts

@@ -0,0 +1,93 @@
+import { OwoMarkSharedState, PreviewBlockKind, PreviewBlock } from '@owomark/core';
+
+type PreviewRenderPhase = 'idle' | 'rendering' | 'highlighting' | 'ready' | 'error';
+type PreviewCacheEntry = {
+    blockId: string;
+    renderKey: string;
+    html: string;
+    highlighted: boolean;
+    themeKey: string;
+    updatedAt: number;
+};
+type PreviewRenderContext = {
+    version: number;
+    themeKey: string;
+    abortSignal?: AbortSignal;
+    /**
+     * Line offset to add to source-line attributes in the rendered HTML.
+     * When a block starts at line N in the document, the renderer processes
+     * its raw content starting from line 1; this offset (N - 1) must be
+     * added to `data-source-line-start/end` so scroll sync anchors map
+     * to the correct document lines.
+     */
+    sourceLineOffset: number;
+};
+type PreviewRenderResult = {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'dom';
+    mount: (container: HTMLElement) => void;
+    unmount?: () => void;
+};
+type PreviewRendererMode = 'html-worker-safe' | 'dom-main-thread';
+type PreviewTaskPriority = 'realtime' | 'deferred';
+type PreviewRendererDefinition = {
+    mode: PreviewRendererMode;
+    priority: PreviewTaskPriority;
+    render: PreviewBlockRenderer;
+    version: string;
+    workerModuleUrl?: string;
+};
+type PreviewBlockRenderer = (block: PreviewBlock, context: PreviewRenderContext) => Promise<PreviewRenderResult> | PreviewRenderResult;
+type PreviewBlockMetadata = {
+    mode: PreviewRendererMode;
+    priority: PreviewTaskPriority;
+    heavy?: boolean;
+};
+type PreviewRendererRegistry = {
+    get(kind: PreviewBlockKind): PreviewRendererDefinition | null;
+    register(kind: PreviewBlockKind, renderer: PreviewRendererDefinition): void;
+    unregister(kind: PreviewBlockKind): void;
+    registerMetadata(kind: PreviewBlockKind, meta: PreviewBlockMetadata): void;
+    isHeavy(kind: PreviewBlockKind): boolean;
+    getMode(kind: PreviewBlockKind): PreviewRendererMode | null;
+    getPriority(kind: PreviewBlockKind): PreviewTaskPriority | null;
+    listRegistered(): PreviewBlockKind[];
+};
+type PreviewTaskScheduler = {
+    submitWorkerTask(block: PreviewBlock, rendererDef: PreviewRendererDefinition, context: PreviewRenderContext): Promise<string>;
+    cancel(taskId: number): void;
+    cancelAll(): void;
+    acquire(): PreviewTaskScheduler;
+    release(): void;
+};
+type PreviewStrategy = 'incremental' | 'virtual' | 'mdx';
+type OwoMarkPreviewEngineOptions = {
+    strategy?: PreviewStrategy;
+    themeKey?: string;
+    registry?: PreviewRendererRegistry;
+    scheduler?: PreviewTaskScheduler;
+    viewportFirst?: boolean;
+    /**
+     * External block renderer function. When provided, the engine uses this
+     * instead of the built-in default renderer. This allows the host to supply
+     * its own Markdown pipeline (unified, remark, rehype, Shiki, etc.) without
+     * the preview package bundling those heavy dependencies.
+     */
+    renderBlock?: (block: PreviewBlock, context: PreviewRenderContext) => Promise<string>;
+    /**
+     * Called after every DOM mutation — including idle-backfilled and deferred
+     * block renders — not just after the synchronous update() return.
+     * Use for scroll sync or other post-DOM-update side effects.
+     */
+    onContentUpdate?: () => void;
+};
+type OwoMarkPreviewEngine = {
+    mount(root: HTMLElement): void;
+    destroy(): void;
+    update(state: OwoMarkSharedState): void;
+    getRenderedVersion(): number;
+};
+
+export type { OwoMarkPreviewEngineOptions as O, PreviewRendererRegistry as P, OwoMarkPreviewEngine as a, PreviewTaskScheduler as b, PreviewBlockMetadata as c, PreviewBlockRenderer as d, PreviewCacheEntry as e, PreviewRenderContext as f, PreviewRenderPhase as g, PreviewRenderResult as h, PreviewRendererDefinition as i, PreviewRendererMode as j, PreviewStrategy as k, PreviewTaskPriority as l };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owomark/view",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Rendering engine, preview engine, DOM view layer, and official base theme for OwoMark.",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,10 +21,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./static": {
-      "types": "./dist/static.d.ts",
-      "import": "./dist/static.js"
-    },
     "./internal/virtual/block-layout-map": {
       "types": "./dist/internal/virtual/block-layout-map.d.ts",
       "import": "./dist/internal/virtual/block-layout-map.js"
@@ -42,7 +38,6 @@
       "import": "./dist/internal/virtual/viewport-manager.js"
     },
     "./style.css": "./src/style.css",
-    "./mdx-components.css": "./src/mdx-components/mdx-components.css",
     "./owomark.css": "./src/theme/owomark.css",
     "./preview.css": "./src/theme/preview.css",
     "./light.css": "./src/theme/light.css",
@@ -53,12 +48,10 @@
   "files": [
     "dist",
     "src/style.css",
-    "src/mdx-components/mdx-components.css",
     "src/theme"
   ],
   "sideEffects": [
     "./src/style.css",
-    "./src/mdx-components/mdx-components.css",
     "./src/theme/*.css"
   ],
   "scripts": {
@@ -69,38 +62,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@owomark/core": "^0.1.4",
-    "rehype-katex": "^6.0.3",
-    "rehype-pretty-code": "^0.14.1",
-    "rehype-slug": "^6.0.0",
-    "rehype-stringify": "^10.0.1",
-    "remark-directive": "^4.0.0",
-    "remark-gfm": "^4.0.1",
-    "remark-math": "^6.0.0",
-    "remark-mdx": "^3.1.0",
-    "remark-parse": "^11.0.0",
-    "remark-rehype": "^11.1.2",
-    "shiki": "^3.23.0",
-    "unified": "^11.0.5"
-  },
-  "peerDependencies": {
-    "@mdx-js/mdx": "^3.0.0",
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@mdx-js/mdx": {
-      "optional": true
-    },
-    "react": {
-      "optional": true
-    },
-    "react-dom": {
-      "optional": true
-    }
+    "@owomark/core": "^0.1.6"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
     "tsup": "^8.5.1"
   }
 }

package/src/style.css

@@ -2,9 +2,6 @@
  * Aggregates structural CSS and official base theme (light + dark presets).
  * Users who want fine-grained control can import each layer individually. */
 
-/* Structural: component skeletons with --owo-* token slots */
-@import './mdx-components/mdx-components.css';
-
 /* Structural: editor base styles consuming --owo-editor-* tokens */
 @import './theme/owomark.css';
 @import './theme/side-annotation.css';

package/src/theme/dark.css

@@ -59,8 +59,14 @@
   --owo-syntax-code-fence: #7f849c;
   --owo-syntax-code-lang: #fab387;
   --owo-syntax-list-marker: #fab387;
+  --owo-syntax-task-marker: #f9c74f;
+  --owo-syntax-task-marker-checked: #a6e3a1;
+  --owo-syntax-table-separator: #6c7086;
+  --owo-syntax-strikethrough: #cdd6f4;
   --owo-syntax-blockquote-marker: #585b70;
   --owo-syntax-hr: #45475a;
+  --owo-syntax-html: #cba6f7;
+  --owo-syntax-math: #94e2d5;
 
   /* Toolbar */
   --owo-toolbar-bg: #252536;