@owomark/core 0.1.5 → 0.1.7

package/README.md

@@ -48,16 +48,7 @@ view.destroy();
 core.destroy();
 ```
 
-The standalone DOM editor API is also available through `@owomark/view`:
-
-```ts
-import { createOwoMarkVanillaEditor } from '@owomark/view';
-
-const editor = createOwoMarkVanillaEditor();
-editor.setMarkdown('# Hello');
-editor.mount(document.getElementById('editor')!);
-editor.destroy();
-```
+Browser hosts should compose `createOwoMarkCore()` with `createOwoMarkView()`. The public API no longer includes a standalone DOM editor entry.
 
 ## Core API
 
@@ -126,6 +117,29 @@ import {
 import { tokenizeBlock, tokenizeInline } from '@owomark/core';
 ```
 
+Parser extension contracts are also exposed for industrial custom syntax integration:
+
+```ts
+import type {
+  InlineSyntaxExtension,
+  BlockSyntaxExtension,
+  ContainerBlockSyntaxExtension,
+  CustomBlockRuntimeBinding,
+} from '@owomark/core';
+```
+
+Current execution support is live for `inline.extensions`, `block.extensions`,
+and `block.containerExtensions`. Block/container extensions now execute through
+the parser, emit formal `custom-block` nodes, and project runtime metadata into
+preview `custom` blocks under the shared `'custom-block-change'` invalidation
+contract.
+
+For the formal syntax-layer contracts that now anchor this extension surface, see:
+
+- [docs/specs/owomark-math.md](/home/qq/proj/qblog/docs/specs/owomark-math.md)
+- [docs/specs/owomark-side-annotation.md](/home/qq/proj/qblog/docs/specs/owomark-side-annotation.md)
+- [docs/specs/owomark-components-extension.md](/home/qq/proj/qblog/docs/specs/owomark-components-extension.md)
+
 ### Model
 
 ```ts
@@ -153,6 +167,12 @@ import { normalizeMarkdownPaste } from '@owomark/core';
 - Fenced code blocks (`` ``` ``)
 - Thematic breaks (`---`)
 
+Formal extension specs:
+
+- Math: [docs/specs/owomark-math.md](/home/qq/proj/qblog/docs/specs/owomark-math.md)
+- Side Annotation: [docs/specs/owomark-side-annotation.md](/home/qq/proj/qblog/docs/specs/owomark-side-annotation.md)
+- Components Extension: [docs/specs/owomark-components-extension.md](/home/qq/proj/qblog/docs/specs/owomark-components-extension.md)
+
 ## Preview Projection
 
 Convert a parsed document into preview-ready blocks for incremental rendering:

package/dist/.build-manifest.json

@@ -0,0 +1,130 @@
+{
+  "schemaVersion": 1,
+  "packageName": "@owomark/core",
+  "packagePath": "owomark/packages/owomark-core",
+  "packageFingerprint": "32024bd874bc287d8de92d6142487720dd3e31af4477e6f91a54b8e8db3aec4e",
+  "workspaceFingerprint": "29c91b05781cfd51984ade38b2b582f8dab1013dfaaf87ed5b2b6e9723653157",
+  "builtAt": "2026-04-23T03:06:11.526Z",
+  "builderVersion": "2026-04-22-industrialization-v1",
+  "inputFiles": [
+    "owomark/package.json",
+    "owomark/packages/owomark-core/package.json",
+    "owomark/packages/owomark-core/src/browser-types.ts",
+    "owomark/packages/owomark-core/src/browser.ts",
+    "owomark/packages/owomark-core/src/clipboard/paste.ts",
+    "owomark/packages/owomark-core/src/commands/backspace.ts",
+    "owomark/packages/owomark-core/src/commands/char-input.ts",
+    "owomark/packages/owomark-core/src/commands/enter.ts",
+    "owomark/packages/owomark-core/src/commands/indent.ts",
+    "owomark/packages/owomark-core/src/commands/inline-format.ts",
+    "owomark/packages/owomark-core/src/commands/slash/builtin-commands.ts",
+    "owomark/packages/owomark-core/src/commands/slash/index.ts",
+    "owomark/packages/owomark-core/src/commands/slash/registry.ts",
+    "owomark/packages/owomark-core/src/commands/slash/slash-manager.ts",
+    "owomark/packages/owomark-core/src/commands/slash/types.ts",
+    "owomark/packages/owomark-core/src/commands/word-boundary.ts",
+    "owomark/packages/owomark-core/src/conformance/document.ts",
+    "owomark/packages/owomark-core/src/core/block-context.ts",
+    "owomark/packages/owomark-core/src/core/core-events.ts",
+    "owomark/packages/owomark-core/src/core/core-selection.ts",
+    "owomark/packages/owomark-core/src/core/core-types.ts",
+    "owomark/packages/owomark-core/src/core/editor-core.ts",
+    "owomark/packages/owomark-core/src/core/index.ts",
+    "owomark/packages/owomark-core/src/index.ts",
+    "owomark/packages/owomark-core/src/internal/clipboard/paste.ts",
+    "owomark/packages/owomark-core/src/internal/commands/word-boundary.ts",
+    "owomark/packages/owomark-core/src/internal/dom-adapter.ts",
+    "owomark/packages/owomark-core/src/model/dirty-range.ts",
+    "owomark/packages/owomark-core/src/model/document/block-factory.ts",
+    "owomark/packages/owomark-core/src/model/document/block-id.ts",
+    "owomark/packages/owomark-core/src/model/document/container-parser.ts",
+    "owomark/packages/owomark-core/src/model/document/container-rules.ts",
+    "owomark/packages/owomark-core/src/model/document/decorators.ts",
+    "owomark/packages/owomark-core/src/model/document/index.ts",
+    "owomark/packages/owomark-core/src/model/document/offsets.ts",
+    "owomark/packages/owomark-core/src/model/document/parse-markdown.ts",
+    "owomark/packages/owomark-core/src/model/document/reconcile.ts",
+    "owomark/packages/owomark-core/src/model/document/serialize.ts",
+    "owomark/packages/owomark-core/src/model/document/side-annotations.ts",
+    "owomark/packages/owomark-core/src/model/selection/block-cache.ts",
+    "owomark/packages/owomark-core/src/model/selection/dom-range.ts",
+    "owomark/packages/owomark-core/src/model/selection/index.ts",
+    "owomark/packages/owomark-core/src/model/selection/linear-dom.ts",
+    "owomark/packages/owomark-core/src/model/virtual-selection.ts",
+    "owomark/packages/owomark-core/src/parser/blocks.ts",
+    "owomark/packages/owomark-core/src/parser/inline-tokens.ts",
+    "owomark/packages/owomark-core/src/patterns/side-annotation.ts",
+    "owomark/packages/owomark-core/src/preview/block-id.ts",
+    "owomark/packages/owomark-core/src/preview/projection.ts",
+    "owomark/packages/owomark-core/src/preview/render-key.ts",
+    "owomark/packages/owomark-core/src/render/block-render.ts",
+    "owomark/packages/owomark-core/src/render/blockquote-bars.ts",
+    "owomark/packages/owomark-core/src/render/dom-patch.ts",
+    "owomark/packages/owomark-core/src/scroll/index.ts",
+    "owomark/packages/owomark-core/src/scroll/progress-engine.ts",
+    "owomark/packages/owomark-core/src/scroll/projection.ts",
+    "owomark/packages/owomark-core/src/scroll/scroll-controller.ts",
+    "owomark/packages/owomark-core/src/scroll/surface-geometry.ts",
+    "owomark/packages/owomark-core/src/scroll/types.ts",
+    "owomark/packages/owomark-core/src/semantic/components/index.ts",
+    "owomark/packages/owomark-core/src/semantic/editor/index.ts",
+    "owomark/packages/owomark-core/src/semantic/index.ts",
+    "owomark/packages/owomark-core/src/semantic/runtime/index.ts",
+    "owomark/packages/owomark-core/src/semantic/shared/index.ts",
+    "owomark/packages/owomark-core/src/semantic/shared/registry.ts",
+    "owomark/packages/owomark-core/src/semantic/shared/types.ts",
+    "owomark/packages/owomark-core/src/semantic/shared/validation.ts",
+    "owomark/packages/owomark-core/src/semantic/syntax/builtin/math.ts",
+    "owomark/packages/owomark-core/src/semantic/syntax/builtin/side-annotation.ts",
+    "owomark/packages/owomark-core/src/semantic/syntax/index.ts",
+    "owomark/packages/owomark-core/src/state/shared-state.ts",
+    "owomark/packages/owomark-core/src/transforms/image-size.ts",
+    "owomark/packages/owomark-core/src/types/public.ts",
+    "owomark/packages/owomark-core/src/virtual/editor-virtual-list.ts",
+    "owomark/packages/owomark-core/tsconfig.json",
+    "owomark/packages/owomark-core/tsup.config.ts",
+    "package-lock.json"
+  ],
+  "artifactFiles": [
+    "dist/browser.d.ts",
+    "dist/browser.js",
+    "dist/chunk-3KTK7CSS.js",
+    "dist/chunk-5JNL3LHV.js",
+    "dist/chunk-ASRCHEFF.js",
+    "dist/chunk-BGXCXQZP.js",
+    "dist/chunk-BKJCBEI7.js",
+    "dist/chunk-CJSBFWKS.js",
+    "dist/chunk-MPIWZLI3.js",
+    "dist/chunk-OOH46GIF.js",
+    "dist/chunk-ROJILHRQ.js",
+    "dist/chunk-SHVM2TPY.js",
+    "dist/chunk-WFPUIPWU.js",
+    "dist/chunk-WXVKSKP3.js",
+    "dist/chunk-YZYJIXGO.js",
+    "dist/editor-core-DtPL3N3I.d.ts",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "dist/internal/clipboard/paste.d.ts",
+    "dist/internal/clipboard/paste.js",
+    "dist/internal/commands/word-boundary.d.ts",
+    "dist/internal/commands/word-boundary.js",
+    "dist/internal/dom-adapter.d.ts",
+    "dist/internal/dom-adapter.js",
+    "dist/public-Dbsa3XRM.d.ts",
+    "dist/registry-D4LeNPxw.d.ts",
+    "dist/semantic/components/index.d.ts",
+    "dist/semantic/components/index.js",
+    "dist/semantic/editor/index.d.ts",
+    "dist/semantic/editor/index.js",
+    "dist/semantic/index.d.ts",
+    "dist/semantic/index.js",
+    "dist/semantic/runtime/index.d.ts",
+    "dist/semantic/runtime/index.js",
+    "dist/semantic/shared/index.d.ts",
+    "dist/semantic/shared/index.js",
+    "dist/semantic/syntax/index.d.ts",
+    "dist/semantic/syntax/index.js",
+    "dist/types-UF6oV7Xu.d.ts"
+  ],
+  "localDependencyFingerprints": {}
+}

package/dist/browser.d.ts

@@ -0,0 +1,66 @@
+import { O as OwoMarkSelection, a as OwoMarkDocument, D as DirtyRange, I as InlineTokenType, e as InlineToken, f as PreviewBlock } from './public-zMo7BR9l.js';
+import { O as OwoMarkScrollProjectionSnapshot, a as OwoMarkSurfaceGeometrySnapshot, b as OwoMarkScrollController } from './types-DMqYF6Zn.js';
+
+declare function invalidateBlockCache(root: HTMLElement): void;
+
+declare function domRangeToOffset(root: HTMLElement, range: {
+    startContainer: Node;
+    startOffset: number;
+    endContainer: Node;
+    endOffset: number;
+}): OwoMarkSelection | null;
+declare function offsetToDomRange(root: HTMLElement, selection: OwoMarkSelection): Range | null;
+
+declare function restoreSelection(root: HTMLElement, selection: OwoMarkSelection): void;
+declare function readSelection(root: HTMLElement): OwoMarkSelection | null;
+
+/**
+ * Incremental DOM patch: only re-render dirty blocks.
+ */
+
+/**
+ * Full render: build entire editor DOM from document model.
+ */
+declare function fullRender(root: HTMLElement, doc: OwoMarkDocument): void;
+/**
+ * Incremental patch: only re-render blocks in dirty range.
+ */
+declare function patchDirtyBlocks(root: HTMLElement, doc: OwoMarkDocument, dirty: DirtyRange): void;
+/**
+ * Detect changed blocks between old and new document, then render minimally.
+ * Falls back to full render when block count changes or no dirty blocks found
+ * despite text difference (structural shift).
+ */
+declare function detectAndRenderDirty(root: HTMLElement, oldDoc: OwoMarkDocument, newDoc: OwoMarkDocument, fullFallback?: boolean): void;
+
+/**
+ * Render a block's inline tokens into DOM nodes within a block container.
+ * Each block is a <div data-owo-block="index"> containing text/span nodes.
+ */
+
+declare const TOKEN_CLASS_EXEMPTIONS: Set<"text" | "strong-marker" | "strong" | "emphasis-marker" | "emphasis" | "custom-inline-marker" | "custom-inline" | "code-marker" | "code" | "link-bracket" | "link-text" | "link-url" | "reference-bracket" | "reference-label" | "image-marker" | "image-alt" | "image-url" | "heading-marker" | "list-marker" | "task-marker" | "task-marker-checked" | "table-separator" | "blockquote-marker" | "fence-marker" | "fence-lang" | "code-block-text" | "strikethrough-marker" | "strikethrough" | "math-marker" | "math-text" | "hr" | "html">;
+declare const TOKEN_TO_CLASS: Record<InlineTokenType, string>;
+declare const BLOCK_TYPE_TO_CLASS: Record<string, string>;
+declare function createBlockElement(doc: Document, tokens: InlineToken[], blockIndex: number, blockType: string, headingLevel?: number, depth?: number): HTMLDivElement;
+/**
+ * Update an existing block element's content with new tokens.
+ * Returns true if the block was modified.
+ */
+declare function updateBlockElement(doc: Document, existing: HTMLDivElement, tokens: InlineToken[], blockType: string, headingLevel?: number, depth?: number): boolean;
+
+declare const BQ_STEP: number;
+/**
+ * Build the CSS box-shadow value for nested blockquote bars.
+ * Returns null when depth <= 1 (no extra bars needed — the first bar is
+ * rendered by the block's own border/class styling).
+ */
+declare function buildBlockquoteBarsBoxShadow(depth: number): string | null;
+
+declare function measureEditorSurfaceGeometry(projection: OwoMarkScrollProjectionSnapshot, editorRoot: HTMLElement, _body?: string): OwoMarkSurfaceGeometrySnapshot;
+declare function measurePreviewSurfaceGeometry(projection: OwoMarkScrollProjectionSnapshot, previewRoot: HTMLElement): OwoMarkSurfaceGeometrySnapshot;
+
+declare function createScrollController(): OwoMarkScrollController & {
+    updateProjection(previewBlocks: readonly PreviewBlock[], documentRevision: number): void;
+};
+
+export { BLOCK_TYPE_TO_CLASS, BQ_STEP, TOKEN_CLASS_EXEMPTIONS, TOKEN_TO_CLASS, buildBlockquoteBarsBoxShadow, createBlockElement, createScrollController, detectAndRenderDirty, domRangeToOffset, fullRender, invalidateBlockCache, measureEditorSurfaceGeometry, measurePreviewSurfaceGeometry, offsetToDomRange, patchDirtyBlocks, readSelection, restoreSelection, updateBlockElement };

package/dist/browser.js

@@ -0,0 +1,396 @@
+import {
+  DEFAULT_VIEWPORT_ANCHOR_RATIO,
+  buildScrollProjectionSnapshot,
+  resolveScrollPosition,
+  resolveScrollTopFromPosition
+} from "./chunk-5JNL3LHV.js";
+import {
+  BLOCK_TYPE_TO_CLASS,
+  BQ_STEP,
+  TOKEN_CLASS_EXEMPTIONS,
+  TOKEN_TO_CLASS,
+  buildBlockquoteBarsBoxShadow,
+  createBlockElement,
+  detectAndRenderDirty,
+  domRangeToOffset,
+  fullRender,
+  invalidateBlockCache,
+  offsetToDomRange,
+  patchDirtyBlocks,
+  readSelection,
+  restoreSelection,
+  updateBlockElement
+} from "./chunk-CJSBFWKS.js";
+import {
+  deriveSourceKey
+} from "./chunk-WFPUIPWU.js";
+
+// src/scroll/surface-geometry.ts
+var geometryRevisionCounter = 0;
+function getOffsetInContainer(el, container) {
+  const elRect = el.getBoundingClientRect();
+  const containerRect = container.getBoundingClientRect();
+  return elRect.top - containerRect.top + container.scrollTop;
+}
+function collectMeasuredSegments(root, selector) {
+  const elements = root.querySelectorAll(selector);
+  const measured = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    const dataset = el.dataset ?? {};
+    const sourceStart = Number(dataset.sourceLineStart);
+    const sourceEnd = Number(dataset.sourceLineEnd) || sourceStart;
+    const sourceKey = dataset.sourceKey ?? (Number.isFinite(sourceStart) ? deriveSourceKey(sourceStart, sourceEnd) : null);
+    if (!sourceKey) {
+      continue;
+    }
+    const top = getOffsetInContainer(el, root);
+    const bottom = top + el.offsetHeight;
+    const existing = measured.get(sourceKey);
+    if (existing) {
+      existing.top = Math.min(existing.top, top);
+      existing.bottom = Math.max(existing.bottom, bottom);
+      continue;
+    }
+    measured.set(sourceKey, { sourceKey, top, bottom });
+  }
+  return measured;
+}
+function measureEditorSurfaceGeometry(projection, editorRoot, _body) {
+  const measured = collectMeasuredSegments(editorRoot, "[data-source-key], [data-source-line-start]");
+  if (measured.size === 0) {
+    const legacyBlocks = editorRoot.querySelectorAll("[data-owo-block]");
+    legacyBlocks.forEach((el, index) => {
+      const projectionSegment = projection.segments[index];
+      if (!projectionSegment) {
+        return;
+      }
+      const top = getOffsetInContainer(el, editorRoot);
+      measured.set(projectionSegment.sourceKey, {
+        sourceKey: projectionSegment.sourceKey,
+        top,
+        bottom: top + el.offsetHeight
+      });
+    });
+  }
+  const segments = [];
+  let unmeasuredCount = 0;
+  for (const seg of projection.segments) {
+    const geo = measured.get(seg.sourceKey);
+    if (geo) {
+      segments.push({
+        sourceKey: seg.sourceKey,
+        top: geo.top,
+        bottom: geo.bottom,
+        height: geo.bottom - geo.top,
+        measured: true
+      });
+    } else {
+      unmeasuredCount++;
+      segments.push({
+        sourceKey: seg.sourceKey,
+        top: 0,
+        bottom: 0,
+        height: 0,
+        measured: false,
+        degradedReason: "segment-not-mounted-yet"
+      });
+    }
+  }
+  const status = unmeasuredCount === 0 ? "ready" : unmeasuredCount === segments.length ? "pending" : "partial";
+  geometryRevisionCounter += 1;
+  return {
+    documentRevision: projection.documentRevision,
+    projectionRevision: projection.projectionRevision,
+    geometryRevision: geometryRevisionCounter,
+    surface: "editor",
+    status,
+    segments
+  };
+}
+function measurePreviewSurfaceGeometry(projection, previewRoot) {
+  const measured = collectMeasuredSegments(previewRoot, "[data-source-line-start], [data-source-key]");
+  const segments = [];
+  let unmeasuredCount = 0;
+  for (const seg of projection.segments) {
+    const geo = measured.get(seg.sourceKey);
+    if (geo) {
+      segments.push({
+        sourceKey: seg.sourceKey,
+        top: geo.top,
+        bottom: geo.bottom,
+        height: geo.bottom - geo.top,
+        measured: true
+      });
+    } else {
+      unmeasuredCount++;
+      segments.push({
+        sourceKey: seg.sourceKey,
+        top: 0,
+        bottom: 0,
+        height: 0,
+        measured: false,
+        degradedReason: "segment-not-mounted-yet"
+      });
+    }
+  }
+  const status = unmeasuredCount === 0 ? "ready" : unmeasuredCount === segments.length ? "pending" : "partial";
+  geometryRevisionCounter += 1;
+  return {
+    documentRevision: projection.documentRevision,
+    projectionRevision: projection.projectionRevision,
+    geometryRevision: geometryRevisionCounter,
+    surface: "preview",
+    status,
+    segments
+  };
+}
+
+// src/scroll/scroll-controller.ts
+function getMeasuredSegment(snapshot, sourceKey) {
+  return snapshot.segments.find((segment) => segment.sourceKey === sourceKey && segment.measured) ?? null;
+}
+function applyScrollTop(root, scrollTop, behavior) {
+  if (typeof root.scrollTo === "function") {
+    root.scrollTo({ top: scrollTop, behavior });
+    return;
+  }
+  root.scrollTop = scrollTop;
+}
+function createScrollController() {
+  let projectionSnapshot = {
+    documentRevision: 0,
+    projectionRevision: 0,
+    segments: []
+  };
+  let lastResolvedPosition = null;
+  const geometrySnapshots = {
+    editor: null,
+    preview: null
+  };
+  const boundRoots = {
+    editor: null,
+    preview: null
+  };
+  const projectionListeners = /* @__PURE__ */ new Set();
+  const geometryListeners = {
+    editor: /* @__PURE__ */ new Set(),
+    preview: /* @__PURE__ */ new Set()
+  };
+  function notifyProjectionListeners() {
+    for (const listener of projectionListeners) {
+      listener(projectionSnapshot);
+    }
+  }
+  function notifyGeometryListeners(surface) {
+    const snapshot = geometrySnapshots[surface];
+    if (!snapshot) return;
+    for (const listener of geometryListeners[surface]) {
+      listener(snapshot);
+    }
+  }
+  function getViewport(root) {
+    return {
+      scrollTop: root.scrollTop,
+      clientHeight: root.clientHeight,
+      scrollHeight: root.scrollHeight
+    };
+  }
+  function remeasureSurface(surface) {
+    const root = boundRoots[surface];
+    if (!root || projectionSnapshot.segments.length === 0) {
+      return null;
+    }
+    const snapshot = surface === "editor" ? measureEditorSurfaceGeometry(projectionSnapshot, root) : measurePreviewSurfaceGeometry(projectionSnapshot, root);
+    geometrySnapshots[surface] = snapshot;
+    notifyGeometryListeners(surface);
+    return snapshot;
+  }
+  function resolveTarget(position, surface, viewportHeight, scrollHeight, viewportAnchorRatio = DEFAULT_VIEWPORT_ANCHOR_RATIO) {
+    const geometry = geometrySnapshots[surface];
+    if (!geometry) {
+      return { ok: false, reason: "surface-not-bound" };
+    }
+    if (position.documentRevision !== projectionSnapshot.documentRevision) {
+      return { ok: false, reason: "document-revision-mismatch" };
+    }
+    if (position.projectionRevision !== projectionSnapshot.projectionRevision) {
+      return { ok: false, reason: "projection-revision-mismatch" };
+    }
+    if (!projectionSnapshot.segments.some((segment) => segment.sourceKey === position.sourceKey)) {
+      return { ok: false, reason: "source-key-not-found" };
+    }
+    if (geometry.status === "pending" || geometry.status === "stale") {
+      return { ok: false, reason: "target-geometry-pending" };
+    }
+    const scrollTop = resolveScrollTopFromPosition(
+      position,
+      projectionSnapshot,
+      geometry,
+      viewportHeight,
+      scrollHeight,
+      viewportAnchorRatio
+    );
+    if (scrollTop == null) {
+      return { ok: false, reason: "target-geometry-pending" };
+    }
+    return {
+      ok: true,
+      scrollTop,
+      precision: geometry.status === "ready" ? "exact" : "provisional"
+    };
+  }
+  function maybeCompensate(surface) {
+    const root = boundRoots[surface];
+    if (!root || !lastResolvedPosition) {
+      return;
+    }
+    const result = resolveTarget(
+      lastResolvedPosition,
+      surface,
+      root.clientHeight,
+      root.scrollHeight
+    );
+    if (!result.ok) {
+      return;
+    }
+    if (Math.abs(root.scrollTop - result.scrollTop) < 1) {
+      return;
+    }
+    applyScrollTop(root, result.scrollTop, "auto");
+  }
+  return {
+    getScrollProjectionSnapshot() {
+      return projectionSnapshot;
+    },
+    subscribeScrollProjectionSnapshot(listener) {
+      projectionListeners.add(listener);
+      return () => {
+        projectionListeners.delete(listener);
+      };
+    },
+    updateProjection(previewBlocks, documentRevision) {
+      projectionSnapshot = buildScrollProjectionSnapshot(previewBlocks, documentRevision);
+      geometrySnapshots.editor = null;
+      geometrySnapshots.preview = null;
+      notifyProjectionListeners();
+      if (boundRoots.editor) remeasureSurface("editor");
+      if (boundRoots.preview) remeasureSurface("preview");
+    },
+    getSurfaceGeometrySnapshot(surface) {
+      return geometrySnapshots[surface];
+    },
+    subscribeSurfaceGeometrySnapshot(surface, listener) {
+      geometryListeners[surface].add(listener);
+      return () => {
+        geometryListeners[surface].delete(listener);
+      };
+    },
+    bindSurface(surface, root) {
+      boundRoots[surface] = root;
+      remeasureSurface(surface);
+    },
+    unbindSurface(surface, root) {
+      if (root && boundRoots[surface] && boundRoots[surface] !== root) {
+        return;
+      }
+      boundRoots[surface] = null;
+      geometrySnapshots[surface] = null;
+    },
+    measureSurface(surface) {
+      const snapshot = remeasureSurface(surface);
+      maybeCompensate(surface);
+      return snapshot;
+    },
+    invalidateGeometry(surface) {
+      const current = geometrySnapshots[surface];
+      if (!current) {
+        return;
+      }
+      geometrySnapshots[surface] = {
+        ...current,
+        status: "stale"
+      };
+      notifyGeometryListeners(surface);
+    },
+    resolveScrollPosition(surface, viewport, viewportAnchorRatio = DEFAULT_VIEWPORT_ANCHOR_RATIO) {
+      const geometry = geometrySnapshots[surface];
+      if (!geometry || geometry.projectionRevision !== projectionSnapshot.projectionRevision) {
+        return null;
+      }
+      const position = resolveScrollPosition(
+        projectionSnapshot,
+        geometry,
+        viewport,
+        viewportAnchorRatio
+      );
+      if (position) {
+        lastResolvedPosition = position;
+      }
+      return position;
+    },
+    resolveScrollTopFromPosition(position, surface, viewportHeight, scrollHeight, viewportAnchorRatio = DEFAULT_VIEWPORT_ANCHOR_RATIO) {
+      return resolveTarget(position, surface, viewportHeight, scrollHeight, viewportAnchorRatio);
+    },
+    scrollToScrollPosition(surface, position, options) {
+      const root = boundRoots[surface];
+      if (!root) {
+        return { ok: false, reason: "surface-not-bound" };
+      }
+      const baseResult = resolveTarget(
+        position,
+        surface,
+        root.clientHeight,
+        root.scrollHeight
+      );
+      if (!baseResult.ok) {
+        return baseResult;
+      }
+      let targetScrollTop = baseResult.scrollTop;
+      const measuredSeg = geometrySnapshots[surface] ? getMeasuredSegment(geometrySnapshots[surface], position.sourceKey) : null;
+      if (measuredSeg) {
+        const offsetTop = options?.offsetTop ?? 0;
+        switch (options?.blockAlign) {
+          case "start":
+            targetScrollTop = measuredSeg.top - offsetTop;
+            break;
+          case "center":
+            targetScrollTop = measuredSeg.top - (root.clientHeight - measuredSeg.height) / 2 - offsetTop;
+            break;
+          case "end":
+            targetScrollTop = measuredSeg.bottom - root.clientHeight - offsetTop;
+            break;
+          default:
+            break;
+        }
+      }
+      const maxScroll = Math.max(0, root.scrollHeight - root.clientHeight);
+      const clamped = Math.max(0, Math.min(maxScroll, targetScrollTop));
+      lastResolvedPosition = position;
+      applyScrollTop(root, clamped, options?.behavior ?? "auto");
+      return {
+        ...baseResult,
+        scrollTop: clamped
+      };
+    }
+  };
+}
+export {
+  BLOCK_TYPE_TO_CLASS,
+  BQ_STEP,
+  TOKEN_CLASS_EXEMPTIONS,
+  TOKEN_TO_CLASS,
+  buildBlockquoteBarsBoxShadow,
+  createBlockElement,
+  createScrollController,
+  detectAndRenderDirty,
+  domRangeToOffset,
+  fullRender,
+  invalidateBlockCache,
+  measureEditorSurfaceGeometry,
+  measurePreviewSurfaceGeometry,
+  offsetToDomRange,
+  patchDirtyBlocks,
+  readSelection,
+  restoreSelection,
+  updateBlockElement
+};